strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    '''
   23
   24    '''
   25    __slots__ = [
   26        'bind_interface',
   27        'certificate_authority',
   28        'client_certificate',
   29        'client_key',
   30        'egress_filter',
   31        'healthcheck_namespace',
   32        'healthy',
   33        'hostname',
   34        'id',
   35        'name',
   36        'port',
   37        'port_override',
   38        'remote_identity_group_id',
   39        'remote_identity_healthcheck_username',
   40        'secret_store_id',
   41        'tags',
   42    ]
   43
   44    def __init__(
   45        self,
   46        bind_interface=None,
   47        certificate_authority=None,
   48        client_certificate=None,
   49        client_key=None,
   50        egress_filter=None,
   51        healthcheck_namespace=None,
   52        healthy=None,
   53        hostname=None,
   54        id=None,
   55        name=None,
   56        port=None,
   57        port_override=None,
   58        remote_identity_group_id=None,
   59        remote_identity_healthcheck_username=None,
   60        secret_store_id=None,
   61        tags=None,
   62    ):
   63        self.bind_interface = bind_interface if bind_interface is not None else ''
   64        '''
   65         Bind interface
   66        '''
   67        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   68        '''
   69
   70        '''
   71        self.client_certificate = client_certificate if client_certificate is not None else ''
   72        '''
   73
   74        '''
   75        self.client_key = client_key if client_key is not None else ''
   76        '''
   77
   78        '''
   79        self.egress_filter = egress_filter if egress_filter is not None else ''
   80        '''
   81         A filter applied to the routing logic to pin datasource to nodes.
   82        '''
   83        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   84        '''
   85         The path used to check the health of your connection.  Defaults to `default`.
   86        '''
   87        self.healthy = healthy if healthy is not None else False
   88        '''
   89         True if the datasource is reachable and the credentials are valid.
   90        '''
   91        self.hostname = hostname if hostname is not None else ''
   92        '''
   93
   94        '''
   95        self.id = id if id is not None else ''
   96        '''
   97         Unique identifier of the Resource.
   98        '''
   99        self.name = name if name is not None else ''
  100        '''
  101         Unique human-readable name of the Resource.
  102        '''
  103        self.port = port if port is not None else 0
  104        '''
  105
  106        '''
  107        self.port_override = port_override if port_override is not None else 0
  108        '''
  109
  110        '''
  111        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  112        '''
  113
  114        '''
  115        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  116        '''
  117
  118        '''
  119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  120        '''
  121         ID of the secret store containing credentials for this resource, if any.
  122        '''
  123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  124        '''
  125         Tags is a map of key, value pairs.
  126        '''
  127
  128    def __repr__(self):
  129        return '<sdm.AKS ' + \
  130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  131            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  132            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  133            'client_key: ' + repr(self.client_key) + ' ' +\
  134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  135            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  136            'healthy: ' + repr(self.healthy) + ' ' +\
  137            'hostname: ' + repr(self.hostname) + ' ' +\
  138            'id: ' + repr(self.id) + ' ' +\
  139            'name: ' + repr(self.name) + ' ' +\
  140            'port: ' + repr(self.port) + ' ' +\
  141            'port_override: ' + repr(self.port_override) + ' ' +\
  142            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  143            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  145            'tags: ' + repr(self.tags) + ' ' +\
  146            '>'
  147
  148    def to_dict(self):
  149        return {
  150            'bind_interface': self.bind_interface,
  151            'certificate_authority': self.certificate_authority,
  152            'client_certificate': self.client_certificate,
  153            'client_key': self.client_key,
  154            'egress_filter': self.egress_filter,
  155            'healthcheck_namespace': self.healthcheck_namespace,
  156            'healthy': self.healthy,
  157            'hostname': self.hostname,
  158            'id': self.id,
  159            'name': self.name,
  160            'port': self.port,
  161            'port_override': self.port_override,
  162            'remote_identity_group_id': self.remote_identity_group_id,
  163            'remote_identity_healthcheck_username':
  164            self.remote_identity_healthcheck_username,
  165            'secret_store_id': self.secret_store_id,
  166            'tags': self.tags,
  167        }
  168
  169    @classmethod
  170    def from_dict(cls, d):
  171        return cls(
  172            bind_interface=d.get('bind_interface'),
  173            certificate_authority=d.get('certificate_authority'),
  174            client_certificate=d.get('client_certificate'),
  175            client_key=d.get('client_key'),
  176            egress_filter=d.get('egress_filter'),
  177            healthcheck_namespace=d.get('healthcheck_namespace'),
  178            healthy=d.get('healthy'),
  179            hostname=d.get('hostname'),
  180            id=d.get('id'),
  181            name=d.get('name'),
  182            port=d.get('port'),
  183            port_override=d.get('port_override'),
  184            remote_identity_group_id=d.get('remote_identity_group_id'),
  185            remote_identity_healthcheck_username=d.get(
  186                'remote_identity_healthcheck_username'),
  187            secret_store_id=d.get('secret_store_id'),
  188            tags=d.get('tags'),
  189        )
  190
  191
  192class AKSBasicAuth:
  193    '''
  194
  195    '''
  196    __slots__ = [
  197        'bind_interface',
  198        'egress_filter',
  199        'healthcheck_namespace',
  200        'healthy',
  201        'hostname',
  202        'id',
  203        'name',
  204        'password',
  205        'port',
  206        'port_override',
  207        'secret_store_id',
  208        'tags',
  209        'username',
  210    ]
  211
  212    def __init__(
  213        self,
  214        bind_interface=None,
  215        egress_filter=None,
  216        healthcheck_namespace=None,
  217        healthy=None,
  218        hostname=None,
  219        id=None,
  220        name=None,
  221        password=None,
  222        port=None,
  223        port_override=None,
  224        secret_store_id=None,
  225        tags=None,
  226        username=None,
  227    ):
  228        self.bind_interface = bind_interface if bind_interface is not None else ''
  229        '''
  230         Bind interface
  231        '''
  232        self.egress_filter = egress_filter if egress_filter is not None else ''
  233        '''
  234         A filter applied to the routing logic to pin datasource to nodes.
  235        '''
  236        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  237        '''
  238         The path used to check the health of your connection.  Defaults to `default`.
  239        '''
  240        self.healthy = healthy if healthy is not None else False
  241        '''
  242         True if the datasource is reachable and the credentials are valid.
  243        '''
  244        self.hostname = hostname if hostname is not None else ''
  245        '''
  246
  247        '''
  248        self.id = id if id is not None else ''
  249        '''
  250         Unique identifier of the Resource.
  251        '''
  252        self.name = name if name is not None else ''
  253        '''
  254         Unique human-readable name of the Resource.
  255        '''
  256        self.password = password if password is not None else ''
  257        '''
  258
  259        '''
  260        self.port = port if port is not None else 0
  261        '''
  262
  263        '''
  264        self.port_override = port_override if port_override is not None else 0
  265        '''
  266
  267        '''
  268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  269        '''
  270         ID of the secret store containing credentials for this resource, if any.
  271        '''
  272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  273        '''
  274         Tags is a map of key, value pairs.
  275        '''
  276        self.username = username if username is not None else ''
  277        '''
  278
  279        '''
  280
  281    def __repr__(self):
  282        return '<sdm.AKSBasicAuth ' + \
  283            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  284            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  285            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  286            'healthy: ' + repr(self.healthy) + ' ' +\
  287            'hostname: ' + repr(self.hostname) + ' ' +\
  288            'id: ' + repr(self.id) + ' ' +\
  289            'name: ' + repr(self.name) + ' ' +\
  290            'password: ' + repr(self.password) + ' ' +\
  291            'port: ' + repr(self.port) + ' ' +\
  292            'port_override: ' + repr(self.port_override) + ' ' +\
  293            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  294            'tags: ' + repr(self.tags) + ' ' +\
  295            'username: ' + repr(self.username) + ' ' +\
  296            '>'
  297
  298    def to_dict(self):
  299        return {
  300            'bind_interface': self.bind_interface,
  301            'egress_filter': self.egress_filter,
  302            'healthcheck_namespace': self.healthcheck_namespace,
  303            'healthy': self.healthy,
  304            'hostname': self.hostname,
  305            'id': self.id,
  306            'name': self.name,
  307            'password': self.password,
  308            'port': self.port,
  309            'port_override': self.port_override,
  310            'secret_store_id': self.secret_store_id,
  311            'tags': self.tags,
  312            'username': self.username,
  313        }
  314
  315    @classmethod
  316    def from_dict(cls, d):
  317        return cls(
  318            bind_interface=d.get('bind_interface'),
  319            egress_filter=d.get('egress_filter'),
  320            healthcheck_namespace=d.get('healthcheck_namespace'),
  321            healthy=d.get('healthy'),
  322            hostname=d.get('hostname'),
  323            id=d.get('id'),
  324            name=d.get('name'),
  325            password=d.get('password'),
  326            port=d.get('port'),
  327            port_override=d.get('port_override'),
  328            secret_store_id=d.get('secret_store_id'),
  329            tags=d.get('tags'),
  330            username=d.get('username'),
  331        )
  332
  333
  334class AKSServiceAccount:
  335    '''
  336
  337    '''
  338    __slots__ = [
  339        'bind_interface',
  340        'egress_filter',
  341        'healthcheck_namespace',
  342        'healthy',
  343        'hostname',
  344        'id',
  345        'name',
  346        'port',
  347        'port_override',
  348        'remote_identity_group_id',
  349        'remote_identity_healthcheck_username',
  350        'secret_store_id',
  351        'tags',
  352        'token',
  353    ]
  354
  355    def __init__(
  356        self,
  357        bind_interface=None,
  358        egress_filter=None,
  359        healthcheck_namespace=None,
  360        healthy=None,
  361        hostname=None,
  362        id=None,
  363        name=None,
  364        port=None,
  365        port_override=None,
  366        remote_identity_group_id=None,
  367        remote_identity_healthcheck_username=None,
  368        secret_store_id=None,
  369        tags=None,
  370        token=None,
  371    ):
  372        self.bind_interface = bind_interface if bind_interface is not None else ''
  373        '''
  374         Bind interface
  375        '''
  376        self.egress_filter = egress_filter if egress_filter is not None else ''
  377        '''
  378         A filter applied to the routing logic to pin datasource to nodes.
  379        '''
  380        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  381        '''
  382         The path used to check the health of your connection.  Defaults to `default`.
  383        '''
  384        self.healthy = healthy if healthy is not None else False
  385        '''
  386         True if the datasource is reachable and the credentials are valid.
  387        '''
  388        self.hostname = hostname if hostname is not None else ''
  389        '''
  390
  391        '''
  392        self.id = id if id is not None else ''
  393        '''
  394         Unique identifier of the Resource.
  395        '''
  396        self.name = name if name is not None else ''
  397        '''
  398         Unique human-readable name of the Resource.
  399        '''
  400        self.port = port if port is not None else 0
  401        '''
  402
  403        '''
  404        self.port_override = port_override if port_override is not None else 0
  405        '''
  406
  407        '''
  408        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  409        '''
  410
  411        '''
  412        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  413        '''
  414
  415        '''
  416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  417        '''
  418         ID of the secret store containing credentials for this resource, if any.
  419        '''
  420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  421        '''
  422         Tags is a map of key, value pairs.
  423        '''
  424        self.token = token if token is not None else ''
  425        '''
  426
  427        '''
  428
  429    def __repr__(self):
  430        return '<sdm.AKSServiceAccount ' + \
  431            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  432            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  433            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  434            'healthy: ' + repr(self.healthy) + ' ' +\
  435            'hostname: ' + repr(self.hostname) + ' ' +\
  436            'id: ' + repr(self.id) + ' ' +\
  437            'name: ' + repr(self.name) + ' ' +\
  438            'port: ' + repr(self.port) + ' ' +\
  439            'port_override: ' + repr(self.port_override) + ' ' +\
  440            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  441            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  442            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  443            'tags: ' + repr(self.tags) + ' ' +\
  444            'token: ' + repr(self.token) + ' ' +\
  445            '>'
  446
  447    def to_dict(self):
  448        return {
  449            'bind_interface': self.bind_interface,
  450            'egress_filter': self.egress_filter,
  451            'healthcheck_namespace': self.healthcheck_namespace,
  452            'healthy': self.healthy,
  453            'hostname': self.hostname,
  454            'id': self.id,
  455            'name': self.name,
  456            'port': self.port,
  457            'port_override': self.port_override,
  458            'remote_identity_group_id': self.remote_identity_group_id,
  459            'remote_identity_healthcheck_username':
  460            self.remote_identity_healthcheck_username,
  461            'secret_store_id': self.secret_store_id,
  462            'tags': self.tags,
  463            'token': self.token,
  464        }
  465
  466    @classmethod
  467    def from_dict(cls, d):
  468        return cls(
  469            bind_interface=d.get('bind_interface'),
  470            egress_filter=d.get('egress_filter'),
  471            healthcheck_namespace=d.get('healthcheck_namespace'),
  472            healthy=d.get('healthy'),
  473            hostname=d.get('hostname'),
  474            id=d.get('id'),
  475            name=d.get('name'),
  476            port=d.get('port'),
  477            port_override=d.get('port_override'),
  478            remote_identity_group_id=d.get('remote_identity_group_id'),
  479            remote_identity_healthcheck_username=d.get(
  480                'remote_identity_healthcheck_username'),
  481            secret_store_id=d.get('secret_store_id'),
  482            tags=d.get('tags'),
  483            token=d.get('token'),
  484        )
  485
  486
  487class AKSServiceAccountUserImpersonation:
  488    '''
  489
  490    '''
  491    __slots__ = [
  492        'bind_interface',
  493        'egress_filter',
  494        'healthcheck_namespace',
  495        'healthy',
  496        'hostname',
  497        'id',
  498        'name',
  499        'port',
  500        'port_override',
  501        'secret_store_id',
  502        'tags',
  503        'token',
  504    ]
  505
  506    def __init__(
  507        self,
  508        bind_interface=None,
  509        egress_filter=None,
  510        healthcheck_namespace=None,
  511        healthy=None,
  512        hostname=None,
  513        id=None,
  514        name=None,
  515        port=None,
  516        port_override=None,
  517        secret_store_id=None,
  518        tags=None,
  519        token=None,
  520    ):
  521        self.bind_interface = bind_interface if bind_interface is not None else ''
  522        '''
  523         Bind interface
  524        '''
  525        self.egress_filter = egress_filter if egress_filter is not None else ''
  526        '''
  527         A filter applied to the routing logic to pin datasource to nodes.
  528        '''
  529        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  530        '''
  531         The path used to check the health of your connection.  Defaults to `default`.
  532        '''
  533        self.healthy = healthy if healthy is not None else False
  534        '''
  535         True if the datasource is reachable and the credentials are valid.
  536        '''
  537        self.hostname = hostname if hostname is not None else ''
  538        '''
  539
  540        '''
  541        self.id = id if id is not None else ''
  542        '''
  543         Unique identifier of the Resource.
  544        '''
  545        self.name = name if name is not None else ''
  546        '''
  547         Unique human-readable name of the Resource.
  548        '''
  549        self.port = port if port is not None else 0
  550        '''
  551
  552        '''
  553        self.port_override = port_override if port_override is not None else 0
  554        '''
  555
  556        '''
  557        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  558        '''
  559         ID of the secret store containing credentials for this resource, if any.
  560        '''
  561        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  562        '''
  563         Tags is a map of key, value pairs.
  564        '''
  565        self.token = token if token is not None else ''
  566        '''
  567
  568        '''
  569
  570    def __repr__(self):
  571        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  573            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  574            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  575            'healthy: ' + repr(self.healthy) + ' ' +\
  576            'hostname: ' + repr(self.hostname) + ' ' +\
  577            'id: ' + repr(self.id) + ' ' +\
  578            'name: ' + repr(self.name) + ' ' +\
  579            'port: ' + repr(self.port) + ' ' +\
  580            'port_override: ' + repr(self.port_override) + ' ' +\
  581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  582            'tags: ' + repr(self.tags) + ' ' +\
  583            'token: ' + repr(self.token) + ' ' +\
  584            '>'
  585
  586    def to_dict(self):
  587        return {
  588            'bind_interface': self.bind_interface,
  589            'egress_filter': self.egress_filter,
  590            'healthcheck_namespace': self.healthcheck_namespace,
  591            'healthy': self.healthy,
  592            'hostname': self.hostname,
  593            'id': self.id,
  594            'name': self.name,
  595            'port': self.port,
  596            'port_override': self.port_override,
  597            'secret_store_id': self.secret_store_id,
  598            'tags': self.tags,
  599            'token': self.token,
  600        }
  601
  602    @classmethod
  603    def from_dict(cls, d):
  604        return cls(
  605            bind_interface=d.get('bind_interface'),
  606            egress_filter=d.get('egress_filter'),
  607            healthcheck_namespace=d.get('healthcheck_namespace'),
  608            healthy=d.get('healthy'),
  609            hostname=d.get('hostname'),
  610            id=d.get('id'),
  611            name=d.get('name'),
  612            port=d.get('port'),
  613            port_override=d.get('port_override'),
  614            secret_store_id=d.get('secret_store_id'),
  615            tags=d.get('tags'),
  616            token=d.get('token'),
  617        )
  618
  619
  620class AKSUserImpersonation:
  621    '''
  622
  623    '''
  624    __slots__ = [
  625        'bind_interface',
  626        'certificate_authority',
  627        'client_certificate',
  628        'client_key',
  629        'egress_filter',
  630        'healthcheck_namespace',
  631        'healthy',
  632        'hostname',
  633        'id',
  634        'name',
  635        'port',
  636        'port_override',
  637        'secret_store_id',
  638        'tags',
  639    ]
  640
  641    def __init__(
  642        self,
  643        bind_interface=None,
  644        certificate_authority=None,
  645        client_certificate=None,
  646        client_key=None,
  647        egress_filter=None,
  648        healthcheck_namespace=None,
  649        healthy=None,
  650        hostname=None,
  651        id=None,
  652        name=None,
  653        port=None,
  654        port_override=None,
  655        secret_store_id=None,
  656        tags=None,
  657    ):
  658        self.bind_interface = bind_interface if bind_interface is not None else ''
  659        '''
  660         Bind interface
  661        '''
  662        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  663        '''
  664
  665        '''
  666        self.client_certificate = client_certificate if client_certificate is not None else ''
  667        '''
  668
  669        '''
  670        self.client_key = client_key if client_key is not None else ''
  671        '''
  672
  673        '''
  674        self.egress_filter = egress_filter if egress_filter is not None else ''
  675        '''
  676         A filter applied to the routing logic to pin datasource to nodes.
  677        '''
  678        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  679        '''
  680         The path used to check the health of your connection.  Defaults to `default`.
  681        '''
  682        self.healthy = healthy if healthy is not None else False
  683        '''
  684         True if the datasource is reachable and the credentials are valid.
  685        '''
  686        self.hostname = hostname if hostname is not None else ''
  687        '''
  688
  689        '''
  690        self.id = id if id is not None else ''
  691        '''
  692         Unique identifier of the Resource.
  693        '''
  694        self.name = name if name is not None else ''
  695        '''
  696         Unique human-readable name of the Resource.
  697        '''
  698        self.port = port if port is not None else 0
  699        '''
  700
  701        '''
  702        self.port_override = port_override if port_override is not None else 0
  703        '''
  704
  705        '''
  706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  707        '''
  708         ID of the secret store containing credentials for this resource, if any.
  709        '''
  710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  711        '''
  712         Tags is a map of key, value pairs.
  713        '''
  714
  715    def __repr__(self):
  716        return '<sdm.AKSUserImpersonation ' + \
  717            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  718            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  719            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  720            'client_key: ' + repr(self.client_key) + ' ' +\
  721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  722            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  723            'healthy: ' + repr(self.healthy) + ' ' +\
  724            'hostname: ' + repr(self.hostname) + ' ' +\
  725            'id: ' + repr(self.id) + ' ' +\
  726            'name: ' + repr(self.name) + ' ' +\
  727            'port: ' + repr(self.port) + ' ' +\
  728            'port_override: ' + repr(self.port_override) + ' ' +\
  729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  730            'tags: ' + repr(self.tags) + ' ' +\
  731            '>'
  732
  733    def to_dict(self):
  734        return {
  735            'bind_interface': self.bind_interface,
  736            'certificate_authority': self.certificate_authority,
  737            'client_certificate': self.client_certificate,
  738            'client_key': self.client_key,
  739            'egress_filter': self.egress_filter,
  740            'healthcheck_namespace': self.healthcheck_namespace,
  741            'healthy': self.healthy,
  742            'hostname': self.hostname,
  743            'id': self.id,
  744            'name': self.name,
  745            'port': self.port,
  746            'port_override': self.port_override,
  747            'secret_store_id': self.secret_store_id,
  748            'tags': self.tags,
  749        }
  750
  751    @classmethod
  752    def from_dict(cls, d):
  753        return cls(
  754            bind_interface=d.get('bind_interface'),
  755            certificate_authority=d.get('certificate_authority'),
  756            client_certificate=d.get('client_certificate'),
  757            client_key=d.get('client_key'),
  758            egress_filter=d.get('egress_filter'),
  759            healthcheck_namespace=d.get('healthcheck_namespace'),
  760            healthy=d.get('healthy'),
  761            hostname=d.get('hostname'),
  762            id=d.get('id'),
  763            name=d.get('name'),
  764            port=d.get('port'),
  765            port_override=d.get('port_override'),
  766            secret_store_id=d.get('secret_store_id'),
  767            tags=d.get('tags'),
  768        )
  769
  770
  771class AWS:
  772    '''
  773
  774    '''
  775    __slots__ = [
  776        'access_key',
  777        'bind_interface',
  778        'egress_filter',
  779        'healthcheck_region',
  780        'healthy',
  781        'id',
  782        'name',
  783        'role_arn',
  784        'role_external_id',
  785        'secret_access_key',
  786        'secret_store_id',
  787        'tags',
  788    ]
  789
  790    def __init__(
  791        self,
  792        access_key=None,
  793        bind_interface=None,
  794        egress_filter=None,
  795        healthcheck_region=None,
  796        healthy=None,
  797        id=None,
  798        name=None,
  799        role_arn=None,
  800        role_external_id=None,
  801        secret_access_key=None,
  802        secret_store_id=None,
  803        tags=None,
  804    ):
  805        self.access_key = access_key if access_key is not None else ''
  806        '''
  807
  808        '''
  809        self.bind_interface = bind_interface if bind_interface is not None else ''
  810        '''
  811         Bind interface
  812        '''
  813        self.egress_filter = egress_filter if egress_filter is not None else ''
  814        '''
  815         A filter applied to the routing logic to pin datasource to nodes.
  816        '''
  817        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  818        '''
  819
  820        '''
  821        self.healthy = healthy if healthy is not None else False
  822        '''
  823         True if the datasource is reachable and the credentials are valid.
  824        '''
  825        self.id = id if id is not None else ''
  826        '''
  827         Unique identifier of the Resource.
  828        '''
  829        self.name = name if name is not None else ''
  830        '''
  831         Unique human-readable name of the Resource.
  832        '''
  833        self.role_arn = role_arn if role_arn is not None else ''
  834        '''
  835
  836        '''
  837        self.role_external_id = role_external_id if role_external_id is not None else ''
  838        '''
  839
  840        '''
  841        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  842        '''
  843
  844        '''
  845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  846        '''
  847         ID of the secret store containing credentials for this resource, if any.
  848        '''
  849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  850        '''
  851         Tags is a map of key, value pairs.
  852        '''
  853
  854    def __repr__(self):
  855        return '<sdm.AWS ' + \
  856            'access_key: ' + repr(self.access_key) + ' ' +\
  857            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  858            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  859            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  860            'healthy: ' + repr(self.healthy) + ' ' +\
  861            'id: ' + repr(self.id) + ' ' +\
  862            'name: ' + repr(self.name) + ' ' +\
  863            'role_arn: ' + repr(self.role_arn) + ' ' +\
  864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  867            'tags: ' + repr(self.tags) + ' ' +\
  868            '>'
  869
  870    def to_dict(self):
  871        return {
  872            'access_key': self.access_key,
  873            'bind_interface': self.bind_interface,
  874            'egress_filter': self.egress_filter,
  875            'healthcheck_region': self.healthcheck_region,
  876            'healthy': self.healthy,
  877            'id': self.id,
  878            'name': self.name,
  879            'role_arn': self.role_arn,
  880            'role_external_id': self.role_external_id,
  881            'secret_access_key': self.secret_access_key,
  882            'secret_store_id': self.secret_store_id,
  883            'tags': self.tags,
  884        }
  885
  886    @classmethod
  887    def from_dict(cls, d):
  888        return cls(
  889            access_key=d.get('access_key'),
  890            bind_interface=d.get('bind_interface'),
  891            egress_filter=d.get('egress_filter'),
  892            healthcheck_region=d.get('healthcheck_region'),
  893            healthy=d.get('healthy'),
  894            id=d.get('id'),
  895            name=d.get('name'),
  896            role_arn=d.get('role_arn'),
  897            role_external_id=d.get('role_external_id'),
  898            secret_access_key=d.get('secret_access_key'),
  899            secret_store_id=d.get('secret_store_id'),
  900            tags=d.get('tags'),
  901        )
  902
  903
  904class AWSStore:
  905    '''
  906
  907    '''
  908    __slots__ = [
  909        'id',
  910        'name',
  911        'region',
  912        'tags',
  913    ]
  914
  915    def __init__(
  916        self,
  917        id=None,
  918        name=None,
  919        region=None,
  920        tags=None,
  921    ):
  922        self.id = id if id is not None else ''
  923        '''
  924         Unique identifier of the SecretStore.
  925        '''
  926        self.name = name if name is not None else ''
  927        '''
  928         Unique human-readable name of the SecretStore.
  929        '''
  930        self.region = region if region is not None else ''
  931        '''
  932
  933        '''
  934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  935        '''
  936         Tags is a map of key, value pairs.
  937        '''
  938
  939    def __repr__(self):
  940        return '<sdm.AWSStore ' + \
  941            'id: ' + repr(self.id) + ' ' +\
  942            'name: ' + repr(self.name) + ' ' +\
  943            'region: ' + repr(self.region) + ' ' +\
  944            'tags: ' + repr(self.tags) + ' ' +\
  945            '>'
  946
  947    def to_dict(self):
  948        return {
  949            'id': self.id,
  950            'name': self.name,
  951            'region': self.region,
  952            'tags': self.tags,
  953        }
  954
  955    @classmethod
  956    def from_dict(cls, d):
  957        return cls(
  958            id=d.get('id'),
  959            name=d.get('name'),
  960            region=d.get('region'),
  961            tags=d.get('tags'),
  962        )
  963
  964
  965class AccountAttachment:
  966    '''
  967     AccountAttachments assign an account to a role.
  968    '''
  969    __slots__ = [
  970        'account_id',
  971        'id',
  972        'role_id',
  973    ]
  974
  975    def __init__(
  976        self,
  977        account_id=None,
  978        id=None,
  979        role_id=None,
  980    ):
  981        self.account_id = account_id if account_id is not None else ''
  982        '''
  983         The id of the account of this AccountAttachment.
  984        '''
  985        self.id = id if id is not None else ''
  986        '''
  987         Unique identifier of the AccountAttachment.
  988        '''
  989        self.role_id = role_id if role_id is not None else ''
  990        '''
  991         The id of the attached role of this AccountAttachment.
  992        '''
  993
  994    def __repr__(self):
  995        return '<sdm.AccountAttachment ' + \
  996            'account_id: ' + repr(self.account_id) + ' ' +\
  997            'id: ' + repr(self.id) + ' ' +\
  998            'role_id: ' + repr(self.role_id) + ' ' +\
  999            '>'
 1000
 1001    def to_dict(self):
 1002        return {
 1003            'account_id': self.account_id,
 1004            'id': self.id,
 1005            'role_id': self.role_id,
 1006        }
 1007
 1008    @classmethod
 1009    def from_dict(cls, d):
 1010        return cls(
 1011            account_id=d.get('account_id'),
 1012            id=d.get('id'),
 1013            role_id=d.get('role_id'),
 1014        )
 1015
 1016
 1017class AccountAttachmentCreateResponse:
 1018    '''
 1019     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1020    '''
 1021    __slots__ = [
 1022        'account_attachment',
 1023        'meta',
 1024        'rate_limit',
 1025    ]
 1026
 1027    def __init__(
 1028        self,
 1029        account_attachment=None,
 1030        meta=None,
 1031        rate_limit=None,
 1032    ):
 1033        self.account_attachment = account_attachment if account_attachment is not None else None
 1034        '''
 1035         The created AccountAttachment.
 1036        '''
 1037        self.meta = meta if meta is not None else None
 1038        '''
 1039         Reserved for future use.
 1040        '''
 1041        self.rate_limit = rate_limit if rate_limit is not None else None
 1042        '''
 1043         Rate limit information.
 1044        '''
 1045
 1046    def __repr__(self):
 1047        return '<sdm.AccountAttachmentCreateResponse ' + \
 1048            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1049            'meta: ' + repr(self.meta) + ' ' +\
 1050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1051            '>'
 1052
 1053    def to_dict(self):
 1054        return {
 1055            'account_attachment': self.account_attachment,
 1056            'meta': self.meta,
 1057            'rate_limit': self.rate_limit,
 1058        }
 1059
 1060    @classmethod
 1061    def from_dict(cls, d):
 1062        return cls(
 1063            account_attachment=d.get('account_attachment'),
 1064            meta=d.get('meta'),
 1065            rate_limit=d.get('rate_limit'),
 1066        )
 1067
 1068
 1069class AccountAttachmentDeleteResponse:
 1070    '''
 1071     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1072    '''
 1073    __slots__ = [
 1074        'meta',
 1075        'rate_limit',
 1076    ]
 1077
 1078    def __init__(
 1079        self,
 1080        meta=None,
 1081        rate_limit=None,
 1082    ):
 1083        self.meta = meta if meta is not None else None
 1084        '''
 1085         Reserved for future use.
 1086        '''
 1087        self.rate_limit = rate_limit if rate_limit is not None else None
 1088        '''
 1089         Rate limit information.
 1090        '''
 1091
 1092    def __repr__(self):
 1093        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1094            'meta: ' + repr(self.meta) + ' ' +\
 1095            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1096            '>'
 1097
 1098    def to_dict(self):
 1099        return {
 1100            'meta': self.meta,
 1101            'rate_limit': self.rate_limit,
 1102        }
 1103
 1104    @classmethod
 1105    def from_dict(cls, d):
 1106        return cls(
 1107            meta=d.get('meta'),
 1108            rate_limit=d.get('rate_limit'),
 1109        )
 1110
 1111
 1112class AccountAttachmentGetResponse:
 1113    '''
 1114     AccountAttachmentGetResponse returns a requested AccountAttachment.
 1115    '''
 1116    __slots__ = [
 1117        'account_attachment',
 1118        'meta',
 1119        'rate_limit',
 1120    ]
 1121
 1122    def __init__(
 1123        self,
 1124        account_attachment=None,
 1125        meta=None,
 1126        rate_limit=None,
 1127    ):
 1128        self.account_attachment = account_attachment if account_attachment is not None else None
 1129        '''
 1130         The requested AccountAttachment.
 1131        '''
 1132        self.meta = meta if meta is not None else None
 1133        '''
 1134         Reserved for future use.
 1135        '''
 1136        self.rate_limit = rate_limit if rate_limit is not None else None
 1137        '''
 1138         Rate limit information.
 1139        '''
 1140
 1141    def __repr__(self):
 1142        return '<sdm.AccountAttachmentGetResponse ' + \
 1143            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1144            'meta: ' + repr(self.meta) + ' ' +\
 1145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1146            '>'
 1147
 1148    def to_dict(self):
 1149        return {
 1150            'account_attachment': self.account_attachment,
 1151            'meta': self.meta,
 1152            'rate_limit': self.rate_limit,
 1153        }
 1154
 1155    @classmethod
 1156    def from_dict(cls, d):
 1157        return cls(
 1158            account_attachment=d.get('account_attachment'),
 1159            meta=d.get('meta'),
 1160            rate_limit=d.get('rate_limit'),
 1161        )
 1162
 1163
 1164class AccountCreateResponse:
 1165    '''
 1166     AccountCreateResponse reports how the Accounts were created in the system.
 1167    '''
 1168    __slots__ = [
 1169        'account',
 1170        'meta',
 1171        'rate_limit',
 1172        'token',
 1173    ]
 1174
 1175    def __init__(
 1176        self,
 1177        account=None,
 1178        meta=None,
 1179        rate_limit=None,
 1180        token=None,
 1181    ):
 1182        self.account = account if account is not None else None
 1183        '''
 1184         The created Account.
 1185        '''
 1186        self.meta = meta if meta is not None else None
 1187        '''
 1188         Reserved for future use.
 1189        '''
 1190        self.rate_limit = rate_limit if rate_limit is not None else None
 1191        '''
 1192         Rate limit information.
 1193        '''
 1194        self.token = token if token is not None else ''
 1195        '''
 1196         The auth token generated for the Account. The Account will use this token to
 1197         authenticate with the strongDM API.
 1198        '''
 1199
 1200    def __repr__(self):
 1201        return '<sdm.AccountCreateResponse ' + \
 1202            'account: ' + repr(self.account) + ' ' +\
 1203            'meta: ' + repr(self.meta) + ' ' +\
 1204            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1205            'token: ' + repr(self.token) + ' ' +\
 1206            '>'
 1207
 1208    def to_dict(self):
 1209        return {
 1210            'account': self.account,
 1211            'meta': self.meta,
 1212            'rate_limit': self.rate_limit,
 1213            'token': self.token,
 1214        }
 1215
 1216    @classmethod
 1217    def from_dict(cls, d):
 1218        return cls(
 1219            account=d.get('account'),
 1220            meta=d.get('meta'),
 1221            rate_limit=d.get('rate_limit'),
 1222            token=d.get('token'),
 1223        )
 1224
 1225
 1226class AccountDeleteResponse:
 1227    '''
 1228     AccountDeleteResponse returns information about a Account that was deleted.
 1229    '''
 1230    __slots__ = [
 1231        'meta',
 1232        'rate_limit',
 1233    ]
 1234
 1235    def __init__(
 1236        self,
 1237        meta=None,
 1238        rate_limit=None,
 1239    ):
 1240        self.meta = meta if meta is not None else None
 1241        '''
 1242         Reserved for future use.
 1243        '''
 1244        self.rate_limit = rate_limit if rate_limit is not None else None
 1245        '''
 1246         Rate limit information.
 1247        '''
 1248
 1249    def __repr__(self):
 1250        return '<sdm.AccountDeleteResponse ' + \
 1251            'meta: ' + repr(self.meta) + ' ' +\
 1252            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1253            '>'
 1254
 1255    def to_dict(self):
 1256        return {
 1257            'meta': self.meta,
 1258            'rate_limit': self.rate_limit,
 1259        }
 1260
 1261    @classmethod
 1262    def from_dict(cls, d):
 1263        return cls(
 1264            meta=d.get('meta'),
 1265            rate_limit=d.get('rate_limit'),
 1266        )
 1267
 1268
 1269class AccountGetResponse:
 1270    '''
 1271     AccountGetResponse returns a requested Account.
 1272    '''
 1273    __slots__ = [
 1274        'account',
 1275        'meta',
 1276        'rate_limit',
 1277    ]
 1278
 1279    def __init__(
 1280        self,
 1281        account=None,
 1282        meta=None,
 1283        rate_limit=None,
 1284    ):
 1285        self.account = account if account is not None else None
 1286        '''
 1287         The requested Account.
 1288        '''
 1289        self.meta = meta if meta is not None else None
 1290        '''
 1291         Reserved for future use.
 1292        '''
 1293        self.rate_limit = rate_limit if rate_limit is not None else None
 1294        '''
 1295         Rate limit information.
 1296        '''
 1297
 1298    def __repr__(self):
 1299        return '<sdm.AccountGetResponse ' + \
 1300            'account: ' + repr(self.account) + ' ' +\
 1301            'meta: ' + repr(self.meta) + ' ' +\
 1302            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1303            '>'
 1304
 1305    def to_dict(self):
 1306        return {
 1307            'account': self.account,
 1308            'meta': self.meta,
 1309            'rate_limit': self.rate_limit,
 1310        }
 1311
 1312    @classmethod
 1313    def from_dict(cls, d):
 1314        return cls(
 1315            account=d.get('account'),
 1316            meta=d.get('meta'),
 1317            rate_limit=d.get('rate_limit'),
 1318        )
 1319
 1320
 1321class AccountGrant:
 1322    '''
 1323     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1324    '''
 1325    __slots__ = [
 1326        'account_id',
 1327        'id',
 1328        'resource_id',
 1329        'start_from',
 1330        'valid_until',
 1331    ]
 1332
 1333    def __init__(
 1334        self,
 1335        account_id=None,
 1336        id=None,
 1337        resource_id=None,
 1338        start_from=None,
 1339        valid_until=None,
 1340    ):
 1341        self.account_id = account_id if account_id is not None else ''
 1342        '''
 1343         The account id of this AccountGrant.
 1344        '''
 1345        self.id = id if id is not None else ''
 1346        '''
 1347         Unique identifier of the AccountGrant.
 1348        '''
 1349        self.resource_id = resource_id if resource_id is not None else ''
 1350        '''
 1351         The resource id of this AccountGrant.
 1352        '''
 1353        self.start_from = start_from if start_from is not None else None
 1354        '''
 1355         The timestamp when the resource will be granted. Optional. Both start_at
 1356         and end_at must be defined together, or not defined at all.
 1357        '''
 1358        self.valid_until = valid_until if valid_until is not None else None
 1359        '''
 1360         The timestamp when the resource grant will expire. Optional. Both
 1361         start_at and end_at must be defined together, or not defined at all.
 1362        '''
 1363
 1364    def __repr__(self):
 1365        return '<sdm.AccountGrant ' + \
 1366            'account_id: ' + repr(self.account_id) + ' ' +\
 1367            'id: ' + repr(self.id) + ' ' +\
 1368            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1369            'start_from: ' + repr(self.start_from) + ' ' +\
 1370            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1371            '>'
 1372
 1373    def to_dict(self):
 1374        return {
 1375            'account_id': self.account_id,
 1376            'id': self.id,
 1377            'resource_id': self.resource_id,
 1378            'start_from': self.start_from,
 1379            'valid_until': self.valid_until,
 1380        }
 1381
 1382    @classmethod
 1383    def from_dict(cls, d):
 1384        return cls(
 1385            account_id=d.get('account_id'),
 1386            id=d.get('id'),
 1387            resource_id=d.get('resource_id'),
 1388            start_from=d.get('start_from'),
 1389            valid_until=d.get('valid_until'),
 1390        )
 1391
 1392
 1393class AccountGrantCreateResponse:
 1394    '''
 1395     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1396    '''
 1397    __slots__ = [
 1398        'account_grant',
 1399        'meta',
 1400        'rate_limit',
 1401    ]
 1402
 1403    def __init__(
 1404        self,
 1405        account_grant=None,
 1406        meta=None,
 1407        rate_limit=None,
 1408    ):
 1409        self.account_grant = account_grant if account_grant is not None else None
 1410        '''
 1411         The created AccountGrant.
 1412        '''
 1413        self.meta = meta if meta is not None else None
 1414        '''
 1415         Reserved for future use.
 1416        '''
 1417        self.rate_limit = rate_limit if rate_limit is not None else None
 1418        '''
 1419         Rate limit information.
 1420        '''
 1421
 1422    def __repr__(self):
 1423        return '<sdm.AccountGrantCreateResponse ' + \
 1424            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1425            'meta: ' + repr(self.meta) + ' ' +\
 1426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1427            '>'
 1428
 1429    def to_dict(self):
 1430        return {
 1431            'account_grant': self.account_grant,
 1432            'meta': self.meta,
 1433            'rate_limit': self.rate_limit,
 1434        }
 1435
 1436    @classmethod
 1437    def from_dict(cls, d):
 1438        return cls(
 1439            account_grant=d.get('account_grant'),
 1440            meta=d.get('meta'),
 1441            rate_limit=d.get('rate_limit'),
 1442        )
 1443
 1444
 1445class AccountGrantDeleteResponse:
 1446    '''
 1447     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1448    '''
 1449    __slots__ = [
 1450        'meta',
 1451        'rate_limit',
 1452    ]
 1453
 1454    def __init__(
 1455        self,
 1456        meta=None,
 1457        rate_limit=None,
 1458    ):
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGrantDeleteResponse ' + \
 1470            'meta: ' + repr(self.meta) + ' ' +\
 1471            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1472            '>'
 1473
 1474    def to_dict(self):
 1475        return {
 1476            'meta': self.meta,
 1477            'rate_limit': self.rate_limit,
 1478        }
 1479
 1480    @classmethod
 1481    def from_dict(cls, d):
 1482        return cls(
 1483            meta=d.get('meta'),
 1484            rate_limit=d.get('rate_limit'),
 1485        )
 1486
 1487
 1488class AccountGrantGetResponse:
 1489    '''
 1490     AccountGrantGetResponse returns a requested AccountGrant.
 1491    '''
 1492    __slots__ = [
 1493        'account_grant',
 1494        'meta',
 1495        'rate_limit',
 1496    ]
 1497
 1498    def __init__(
 1499        self,
 1500        account_grant=None,
 1501        meta=None,
 1502        rate_limit=None,
 1503    ):
 1504        self.account_grant = account_grant if account_grant is not None else None
 1505        '''
 1506         The requested AccountGrant.
 1507        '''
 1508        self.meta = meta if meta is not None else None
 1509        '''
 1510         Reserved for future use.
 1511        '''
 1512        self.rate_limit = rate_limit if rate_limit is not None else None
 1513        '''
 1514         Rate limit information.
 1515        '''
 1516
 1517    def __repr__(self):
 1518        return '<sdm.AccountGrantGetResponse ' + \
 1519            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1520            'meta: ' + repr(self.meta) + ' ' +\
 1521            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1522            '>'
 1523
 1524    def to_dict(self):
 1525        return {
 1526            'account_grant': self.account_grant,
 1527            'meta': self.meta,
 1528            'rate_limit': self.rate_limit,
 1529        }
 1530
 1531    @classmethod
 1532    def from_dict(cls, d):
 1533        return cls(
 1534            account_grant=d.get('account_grant'),
 1535            meta=d.get('meta'),
 1536            rate_limit=d.get('rate_limit'),
 1537        )
 1538
 1539
 1540class AccountUpdateResponse:
 1541    '''
 1542     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1543     a AccountUpdateRequest.
 1544    '''
 1545    __slots__ = [
 1546        'account',
 1547        'meta',
 1548        'rate_limit',
 1549    ]
 1550
 1551    def __init__(
 1552        self,
 1553        account=None,
 1554        meta=None,
 1555        rate_limit=None,
 1556    ):
 1557        self.account = account if account is not None else None
 1558        '''
 1559         The updated Account.
 1560        '''
 1561        self.meta = meta if meta is not None else None
 1562        '''
 1563         Reserved for future use.
 1564        '''
 1565        self.rate_limit = rate_limit if rate_limit is not None else None
 1566        '''
 1567         Rate limit information.
 1568        '''
 1569
 1570    def __repr__(self):
 1571        return '<sdm.AccountUpdateResponse ' + \
 1572            'account: ' + repr(self.account) + ' ' +\
 1573            'meta: ' + repr(self.meta) + ' ' +\
 1574            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1575            '>'
 1576
 1577    def to_dict(self):
 1578        return {
 1579            'account': self.account,
 1580            'meta': self.meta,
 1581            'rate_limit': self.rate_limit,
 1582        }
 1583
 1584    @classmethod
 1585    def from_dict(cls, d):
 1586        return cls(
 1587            account=d.get('account'),
 1588            meta=d.get('meta'),
 1589            rate_limit=d.get('rate_limit'),
 1590        )
 1591
 1592
 1593class AmazonEKS:
 1594    '''
 1595
 1596    '''
 1597    __slots__ = [
 1598        'access_key',
 1599        'bind_interface',
 1600        'certificate_authority',
 1601        'cluster_name',
 1602        'egress_filter',
 1603        'endpoint',
 1604        'healthcheck_namespace',
 1605        'healthy',
 1606        'id',
 1607        'name',
 1608        'region',
 1609        'remote_identity_group_id',
 1610        'remote_identity_healthcheck_username',
 1611        'role_arn',
 1612        'role_external_id',
 1613        'secret_access_key',
 1614        'secret_store_id',
 1615        'tags',
 1616    ]
 1617
 1618    def __init__(
 1619        self,
 1620        access_key=None,
 1621        bind_interface=None,
 1622        certificate_authority=None,
 1623        cluster_name=None,
 1624        egress_filter=None,
 1625        endpoint=None,
 1626        healthcheck_namespace=None,
 1627        healthy=None,
 1628        id=None,
 1629        name=None,
 1630        region=None,
 1631        remote_identity_group_id=None,
 1632        remote_identity_healthcheck_username=None,
 1633        role_arn=None,
 1634        role_external_id=None,
 1635        secret_access_key=None,
 1636        secret_store_id=None,
 1637        tags=None,
 1638    ):
 1639        self.access_key = access_key if access_key is not None else ''
 1640        '''
 1641
 1642        '''
 1643        self.bind_interface = bind_interface if bind_interface is not None else ''
 1644        '''
 1645         Bind interface
 1646        '''
 1647        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1648        '''
 1649
 1650        '''
 1651        self.cluster_name = cluster_name if cluster_name is not None else ''
 1652        '''
 1653
 1654        '''
 1655        self.egress_filter = egress_filter if egress_filter is not None else ''
 1656        '''
 1657         A filter applied to the routing logic to pin datasource to nodes.
 1658        '''
 1659        self.endpoint = endpoint if endpoint is not None else ''
 1660        '''
 1661
 1662        '''
 1663        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1664        '''
 1665         The path used to check the health of your connection.  Defaults to `default`.
 1666        '''
 1667        self.healthy = healthy if healthy is not None else False
 1668        '''
 1669         True if the datasource is reachable and the credentials are valid.
 1670        '''
 1671        self.id = id if id is not None else ''
 1672        '''
 1673         Unique identifier of the Resource.
 1674        '''
 1675        self.name = name if name is not None else ''
 1676        '''
 1677         Unique human-readable name of the Resource.
 1678        '''
 1679        self.region = region if region is not None else ''
 1680        '''
 1681
 1682        '''
 1683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1684        '''
 1685
 1686        '''
 1687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1688        '''
 1689
 1690        '''
 1691        self.role_arn = role_arn if role_arn is not None else ''
 1692        '''
 1693
 1694        '''
 1695        self.role_external_id = role_external_id if role_external_id is not None else ''
 1696        '''
 1697
 1698        '''
 1699        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1700        '''
 1701
 1702        '''
 1703        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1704        '''
 1705         ID of the secret store containing credentials for this resource, if any.
 1706        '''
 1707        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1708        '''
 1709         Tags is a map of key, value pairs.
 1710        '''
 1711
 1712    def __repr__(self):
 1713        return '<sdm.AmazonEKS ' + \
 1714            'access_key: ' + repr(self.access_key) + ' ' +\
 1715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1716            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1717            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1719            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1720            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1721            'healthy: ' + repr(self.healthy) + ' ' +\
 1722            'id: ' + repr(self.id) + ' ' +\
 1723            'name: ' + repr(self.name) + ' ' +\
 1724            'region: ' + repr(self.region) + ' ' +\
 1725            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1726            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1727            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1728            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1729            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1731            'tags: ' + repr(self.tags) + ' ' +\
 1732            '>'
 1733
 1734    def to_dict(self):
 1735        return {
 1736            'access_key': self.access_key,
 1737            'bind_interface': self.bind_interface,
 1738            'certificate_authority': self.certificate_authority,
 1739            'cluster_name': self.cluster_name,
 1740            'egress_filter': self.egress_filter,
 1741            'endpoint': self.endpoint,
 1742            'healthcheck_namespace': self.healthcheck_namespace,
 1743            'healthy': self.healthy,
 1744            'id': self.id,
 1745            'name': self.name,
 1746            'region': self.region,
 1747            'remote_identity_group_id': self.remote_identity_group_id,
 1748            'remote_identity_healthcheck_username':
 1749            self.remote_identity_healthcheck_username,
 1750            'role_arn': self.role_arn,
 1751            'role_external_id': self.role_external_id,
 1752            'secret_access_key': self.secret_access_key,
 1753            'secret_store_id': self.secret_store_id,
 1754            'tags': self.tags,
 1755        }
 1756
 1757    @classmethod
 1758    def from_dict(cls, d):
 1759        return cls(
 1760            access_key=d.get('access_key'),
 1761            bind_interface=d.get('bind_interface'),
 1762            certificate_authority=d.get('certificate_authority'),
 1763            cluster_name=d.get('cluster_name'),
 1764            egress_filter=d.get('egress_filter'),
 1765            endpoint=d.get('endpoint'),
 1766            healthcheck_namespace=d.get('healthcheck_namespace'),
 1767            healthy=d.get('healthy'),
 1768            id=d.get('id'),
 1769            name=d.get('name'),
 1770            region=d.get('region'),
 1771            remote_identity_group_id=d.get('remote_identity_group_id'),
 1772            remote_identity_healthcheck_username=d.get(
 1773                'remote_identity_healthcheck_username'),
 1774            role_arn=d.get('role_arn'),
 1775            role_external_id=d.get('role_external_id'),
 1776            secret_access_key=d.get('secret_access_key'),
 1777            secret_store_id=d.get('secret_store_id'),
 1778            tags=d.get('tags'),
 1779        )
 1780
 1781
 1782class AmazonEKSUserImpersonation:
 1783    '''
 1784
 1785    '''
 1786    __slots__ = [
 1787        'access_key',
 1788        'bind_interface',
 1789        'certificate_authority',
 1790        'cluster_name',
 1791        'egress_filter',
 1792        'endpoint',
 1793        'healthcheck_namespace',
 1794        'healthy',
 1795        'id',
 1796        'name',
 1797        'region',
 1798        'role_arn',
 1799        'role_external_id',
 1800        'secret_access_key',
 1801        'secret_store_id',
 1802        'tags',
 1803    ]
 1804
 1805    def __init__(
 1806        self,
 1807        access_key=None,
 1808        bind_interface=None,
 1809        certificate_authority=None,
 1810        cluster_name=None,
 1811        egress_filter=None,
 1812        endpoint=None,
 1813        healthcheck_namespace=None,
 1814        healthy=None,
 1815        id=None,
 1816        name=None,
 1817        region=None,
 1818        role_arn=None,
 1819        role_external_id=None,
 1820        secret_access_key=None,
 1821        secret_store_id=None,
 1822        tags=None,
 1823    ):
 1824        self.access_key = access_key if access_key is not None else ''
 1825        '''
 1826
 1827        '''
 1828        self.bind_interface = bind_interface if bind_interface is not None else ''
 1829        '''
 1830         Bind interface
 1831        '''
 1832        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1833        '''
 1834
 1835        '''
 1836        self.cluster_name = cluster_name if cluster_name is not None else ''
 1837        '''
 1838
 1839        '''
 1840        self.egress_filter = egress_filter if egress_filter is not None else ''
 1841        '''
 1842         A filter applied to the routing logic to pin datasource to nodes.
 1843        '''
 1844        self.endpoint = endpoint if endpoint is not None else ''
 1845        '''
 1846
 1847        '''
 1848        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1849        '''
 1850         The path used to check the health of your connection.  Defaults to `default`.
 1851        '''
 1852        self.healthy = healthy if healthy is not None else False
 1853        '''
 1854         True if the datasource is reachable and the credentials are valid.
 1855        '''
 1856        self.id = id if id is not None else ''
 1857        '''
 1858         Unique identifier of the Resource.
 1859        '''
 1860        self.name = name if name is not None else ''
 1861        '''
 1862         Unique human-readable name of the Resource.
 1863        '''
 1864        self.region = region if region is not None else ''
 1865        '''
 1866
 1867        '''
 1868        self.role_arn = role_arn if role_arn is not None else ''
 1869        '''
 1870
 1871        '''
 1872        self.role_external_id = role_external_id if role_external_id is not None else ''
 1873        '''
 1874
 1875        '''
 1876        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1877        '''
 1878
 1879        '''
 1880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1881        '''
 1882         ID of the secret store containing credentials for this resource, if any.
 1883        '''
 1884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1885        '''
 1886         Tags is a map of key, value pairs.
 1887        '''
 1888
 1889    def __repr__(self):
 1890        return '<sdm.AmazonEKSUserImpersonation ' + \
 1891            'access_key: ' + repr(self.access_key) + ' ' +\
 1892            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1893            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1894            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1895            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1896            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1897            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1898            'healthy: ' + repr(self.healthy) + ' ' +\
 1899            'id: ' + repr(self.id) + ' ' +\
 1900            'name: ' + repr(self.name) + ' ' +\
 1901            'region: ' + repr(self.region) + ' ' +\
 1902            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1903            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1904            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1905            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1906            'tags: ' + repr(self.tags) + ' ' +\
 1907            '>'
 1908
 1909    def to_dict(self):
 1910        return {
 1911            'access_key': self.access_key,
 1912            'bind_interface': self.bind_interface,
 1913            'certificate_authority': self.certificate_authority,
 1914            'cluster_name': self.cluster_name,
 1915            'egress_filter': self.egress_filter,
 1916            'endpoint': self.endpoint,
 1917            'healthcheck_namespace': self.healthcheck_namespace,
 1918            'healthy': self.healthy,
 1919            'id': self.id,
 1920            'name': self.name,
 1921            'region': self.region,
 1922            'role_arn': self.role_arn,
 1923            'role_external_id': self.role_external_id,
 1924            'secret_access_key': self.secret_access_key,
 1925            'secret_store_id': self.secret_store_id,
 1926            'tags': self.tags,
 1927        }
 1928
 1929    @classmethod
 1930    def from_dict(cls, d):
 1931        return cls(
 1932            access_key=d.get('access_key'),
 1933            bind_interface=d.get('bind_interface'),
 1934            certificate_authority=d.get('certificate_authority'),
 1935            cluster_name=d.get('cluster_name'),
 1936            egress_filter=d.get('egress_filter'),
 1937            endpoint=d.get('endpoint'),
 1938            healthcheck_namespace=d.get('healthcheck_namespace'),
 1939            healthy=d.get('healthy'),
 1940            id=d.get('id'),
 1941            name=d.get('name'),
 1942            region=d.get('region'),
 1943            role_arn=d.get('role_arn'),
 1944            role_external_id=d.get('role_external_id'),
 1945            secret_access_key=d.get('secret_access_key'),
 1946            secret_store_id=d.get('secret_store_id'),
 1947            tags=d.get('tags'),
 1948        )
 1949
 1950
 1951class AmazonES:
 1952    '''
 1953
 1954    '''
 1955    __slots__ = [
 1956        'access_key',
 1957        'bind_interface',
 1958        'egress_filter',
 1959        'endpoint',
 1960        'healthy',
 1961        'id',
 1962        'name',
 1963        'port_override',
 1964        'region',
 1965        'role_arn',
 1966        'role_external_id',
 1967        'secret_access_key',
 1968        'secret_store_id',
 1969        'tags',
 1970    ]
 1971
 1972    def __init__(
 1973        self,
 1974        access_key=None,
 1975        bind_interface=None,
 1976        egress_filter=None,
 1977        endpoint=None,
 1978        healthy=None,
 1979        id=None,
 1980        name=None,
 1981        port_override=None,
 1982        region=None,
 1983        role_arn=None,
 1984        role_external_id=None,
 1985        secret_access_key=None,
 1986        secret_store_id=None,
 1987        tags=None,
 1988    ):
 1989        self.access_key = access_key if access_key is not None else ''
 1990        '''
 1991
 1992        '''
 1993        self.bind_interface = bind_interface if bind_interface is not None else ''
 1994        '''
 1995         Bind interface
 1996        '''
 1997        self.egress_filter = egress_filter if egress_filter is not None else ''
 1998        '''
 1999         A filter applied to the routing logic to pin datasource to nodes.
 2000        '''
 2001        self.endpoint = endpoint if endpoint is not None else ''
 2002        '''
 2003
 2004        '''
 2005        self.healthy = healthy if healthy is not None else False
 2006        '''
 2007         True if the datasource is reachable and the credentials are valid.
 2008        '''
 2009        self.id = id if id is not None else ''
 2010        '''
 2011         Unique identifier of the Resource.
 2012        '''
 2013        self.name = name if name is not None else ''
 2014        '''
 2015         Unique human-readable name of the Resource.
 2016        '''
 2017        self.port_override = port_override if port_override is not None else 0
 2018        '''
 2019
 2020        '''
 2021        self.region = region if region is not None else ''
 2022        '''
 2023
 2024        '''
 2025        self.role_arn = role_arn if role_arn is not None else ''
 2026        '''
 2027
 2028        '''
 2029        self.role_external_id = role_external_id if role_external_id is not None else ''
 2030        '''
 2031
 2032        '''
 2033        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2034        '''
 2035
 2036        '''
 2037        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2038        '''
 2039         ID of the secret store containing credentials for this resource, if any.
 2040        '''
 2041        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2042        '''
 2043         Tags is a map of key, value pairs.
 2044        '''
 2045
 2046    def __repr__(self):
 2047        return '<sdm.AmazonES ' + \
 2048            'access_key: ' + repr(self.access_key) + ' ' +\
 2049            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2050            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2051            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2052            'healthy: ' + repr(self.healthy) + ' ' +\
 2053            'id: ' + repr(self.id) + ' ' +\
 2054            'name: ' + repr(self.name) + ' ' +\
 2055            'port_override: ' + repr(self.port_override) + ' ' +\
 2056            'region: ' + repr(self.region) + ' ' +\
 2057            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2058            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2059            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2060            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2061            'tags: ' + repr(self.tags) + ' ' +\
 2062            '>'
 2063
 2064    def to_dict(self):
 2065        return {
 2066            'access_key': self.access_key,
 2067            'bind_interface': self.bind_interface,
 2068            'egress_filter': self.egress_filter,
 2069            'endpoint': self.endpoint,
 2070            'healthy': self.healthy,
 2071            'id': self.id,
 2072            'name': self.name,
 2073            'port_override': self.port_override,
 2074            'region': self.region,
 2075            'role_arn': self.role_arn,
 2076            'role_external_id': self.role_external_id,
 2077            'secret_access_key': self.secret_access_key,
 2078            'secret_store_id': self.secret_store_id,
 2079            'tags': self.tags,
 2080        }
 2081
 2082    @classmethod
 2083    def from_dict(cls, d):
 2084        return cls(
 2085            access_key=d.get('access_key'),
 2086            bind_interface=d.get('bind_interface'),
 2087            egress_filter=d.get('egress_filter'),
 2088            endpoint=d.get('endpoint'),
 2089            healthy=d.get('healthy'),
 2090            id=d.get('id'),
 2091            name=d.get('name'),
 2092            port_override=d.get('port_override'),
 2093            region=d.get('region'),
 2094            role_arn=d.get('role_arn'),
 2095            role_external_id=d.get('role_external_id'),
 2096            secret_access_key=d.get('secret_access_key'),
 2097            secret_store_id=d.get('secret_store_id'),
 2098            tags=d.get('tags'),
 2099        )
 2100
 2101
 2102class AmazonMQAMQP091:
 2103    '''
 2104
 2105    '''
 2106    __slots__ = [
 2107        'bind_interface',
 2108        'egress_filter',
 2109        'healthy',
 2110        'hostname',
 2111        'id',
 2112        'name',
 2113        'password',
 2114        'port',
 2115        'port_override',
 2116        'secret_store_id',
 2117        'tags',
 2118        'tls_required',
 2119        'username',
 2120    ]
 2121
 2122    def __init__(
 2123        self,
 2124        bind_interface=None,
 2125        egress_filter=None,
 2126        healthy=None,
 2127        hostname=None,
 2128        id=None,
 2129        name=None,
 2130        password=None,
 2131        port=None,
 2132        port_override=None,
 2133        secret_store_id=None,
 2134        tags=None,
 2135        tls_required=None,
 2136        username=None,
 2137    ):
 2138        self.bind_interface = bind_interface if bind_interface is not None else ''
 2139        '''
 2140         Bind interface
 2141        '''
 2142        self.egress_filter = egress_filter if egress_filter is not None else ''
 2143        '''
 2144         A filter applied to the routing logic to pin datasource to nodes.
 2145        '''
 2146        self.healthy = healthy if healthy is not None else False
 2147        '''
 2148         True if the datasource is reachable and the credentials are valid.
 2149        '''
 2150        self.hostname = hostname if hostname is not None else ''
 2151        '''
 2152
 2153        '''
 2154        self.id = id if id is not None else ''
 2155        '''
 2156         Unique identifier of the Resource.
 2157        '''
 2158        self.name = name if name is not None else ''
 2159        '''
 2160         Unique human-readable name of the Resource.
 2161        '''
 2162        self.password = password if password is not None else ''
 2163        '''
 2164
 2165        '''
 2166        self.port = port if port is not None else 0
 2167        '''
 2168
 2169        '''
 2170        self.port_override = port_override if port_override is not None else 0
 2171        '''
 2172
 2173        '''
 2174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2175        '''
 2176         ID of the secret store containing credentials for this resource, if any.
 2177        '''
 2178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2179        '''
 2180         Tags is a map of key, value pairs.
 2181        '''
 2182        self.tls_required = tls_required if tls_required is not None else False
 2183        '''
 2184
 2185        '''
 2186        self.username = username if username is not None else ''
 2187        '''
 2188
 2189        '''
 2190
 2191    def __repr__(self):
 2192        return '<sdm.AmazonMQAMQP091 ' + \
 2193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2195            'healthy: ' + repr(self.healthy) + ' ' +\
 2196            'hostname: ' + repr(self.hostname) + ' ' +\
 2197            'id: ' + repr(self.id) + ' ' +\
 2198            'name: ' + repr(self.name) + ' ' +\
 2199            'password: ' + repr(self.password) + ' ' +\
 2200            'port: ' + repr(self.port) + ' ' +\
 2201            'port_override: ' + repr(self.port_override) + ' ' +\
 2202            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2203            'tags: ' + repr(self.tags) + ' ' +\
 2204            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2205            'username: ' + repr(self.username) + ' ' +\
 2206            '>'
 2207
 2208    def to_dict(self):
 2209        return {
 2210            'bind_interface': self.bind_interface,
 2211            'egress_filter': self.egress_filter,
 2212            'healthy': self.healthy,
 2213            'hostname': self.hostname,
 2214            'id': self.id,
 2215            'name': self.name,
 2216            'password': self.password,
 2217            'port': self.port,
 2218            'port_override': self.port_override,
 2219            'secret_store_id': self.secret_store_id,
 2220            'tags': self.tags,
 2221            'tls_required': self.tls_required,
 2222            'username': self.username,
 2223        }
 2224
 2225    @classmethod
 2226    def from_dict(cls, d):
 2227        return cls(
 2228            bind_interface=d.get('bind_interface'),
 2229            egress_filter=d.get('egress_filter'),
 2230            healthy=d.get('healthy'),
 2231            hostname=d.get('hostname'),
 2232            id=d.get('id'),
 2233            name=d.get('name'),
 2234            password=d.get('password'),
 2235            port=d.get('port'),
 2236            port_override=d.get('port_override'),
 2237            secret_store_id=d.get('secret_store_id'),
 2238            tags=d.get('tags'),
 2239            tls_required=d.get('tls_required'),
 2240            username=d.get('username'),
 2241        )
 2242
 2243
 2244class Athena:
 2245    '''
 2246
 2247    '''
 2248    __slots__ = [
 2249        'access_key',
 2250        'bind_interface',
 2251        'egress_filter',
 2252        'healthy',
 2253        'id',
 2254        'name',
 2255        'output',
 2256        'port_override',
 2257        'region',
 2258        'role_arn',
 2259        'role_external_id',
 2260        'secret_access_key',
 2261        'secret_store_id',
 2262        'tags',
 2263    ]
 2264
 2265    def __init__(
 2266        self,
 2267        access_key=None,
 2268        bind_interface=None,
 2269        egress_filter=None,
 2270        healthy=None,
 2271        id=None,
 2272        name=None,
 2273        output=None,
 2274        port_override=None,
 2275        region=None,
 2276        role_arn=None,
 2277        role_external_id=None,
 2278        secret_access_key=None,
 2279        secret_store_id=None,
 2280        tags=None,
 2281    ):
 2282        self.access_key = access_key if access_key is not None else ''
 2283        '''
 2284
 2285        '''
 2286        self.bind_interface = bind_interface if bind_interface is not None else ''
 2287        '''
 2288         Bind interface
 2289        '''
 2290        self.egress_filter = egress_filter if egress_filter is not None else ''
 2291        '''
 2292         A filter applied to the routing logic to pin datasource to nodes.
 2293        '''
 2294        self.healthy = healthy if healthy is not None else False
 2295        '''
 2296         True if the datasource is reachable and the credentials are valid.
 2297        '''
 2298        self.id = id if id is not None else ''
 2299        '''
 2300         Unique identifier of the Resource.
 2301        '''
 2302        self.name = name if name is not None else ''
 2303        '''
 2304         Unique human-readable name of the Resource.
 2305        '''
 2306        self.output = output if output is not None else ''
 2307        '''
 2308
 2309        '''
 2310        self.port_override = port_override if port_override is not None else 0
 2311        '''
 2312
 2313        '''
 2314        self.region = region if region is not None else ''
 2315        '''
 2316
 2317        '''
 2318        self.role_arn = role_arn if role_arn is not None else ''
 2319        '''
 2320
 2321        '''
 2322        self.role_external_id = role_external_id if role_external_id is not None else ''
 2323        '''
 2324
 2325        '''
 2326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2327        '''
 2328
 2329        '''
 2330        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2331        '''
 2332         ID of the secret store containing credentials for this resource, if any.
 2333        '''
 2334        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2335        '''
 2336         Tags is a map of key, value pairs.
 2337        '''
 2338
 2339    def __repr__(self):
 2340        return '<sdm.Athena ' + \
 2341            'access_key: ' + repr(self.access_key) + ' ' +\
 2342            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2343            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2344            'healthy: ' + repr(self.healthy) + ' ' +\
 2345            'id: ' + repr(self.id) + ' ' +\
 2346            'name: ' + repr(self.name) + ' ' +\
 2347            'output: ' + repr(self.output) + ' ' +\
 2348            'port_override: ' + repr(self.port_override) + ' ' +\
 2349            'region: ' + repr(self.region) + ' ' +\
 2350            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2351            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2352            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2353            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2354            'tags: ' + repr(self.tags) + ' ' +\
 2355            '>'
 2356
 2357    def to_dict(self):
 2358        return {
 2359            'access_key': self.access_key,
 2360            'bind_interface': self.bind_interface,
 2361            'egress_filter': self.egress_filter,
 2362            'healthy': self.healthy,
 2363            'id': self.id,
 2364            'name': self.name,
 2365            'output': self.output,
 2366            'port_override': self.port_override,
 2367            'region': self.region,
 2368            'role_arn': self.role_arn,
 2369            'role_external_id': self.role_external_id,
 2370            'secret_access_key': self.secret_access_key,
 2371            'secret_store_id': self.secret_store_id,
 2372            'tags': self.tags,
 2373        }
 2374
 2375    @classmethod
 2376    def from_dict(cls, d):
 2377        return cls(
 2378            access_key=d.get('access_key'),
 2379            bind_interface=d.get('bind_interface'),
 2380            egress_filter=d.get('egress_filter'),
 2381            healthy=d.get('healthy'),
 2382            id=d.get('id'),
 2383            name=d.get('name'),
 2384            output=d.get('output'),
 2385            port_override=d.get('port_override'),
 2386            region=d.get('region'),
 2387            role_arn=d.get('role_arn'),
 2388            role_external_id=d.get('role_external_id'),
 2389            secret_access_key=d.get('secret_access_key'),
 2390            secret_store_id=d.get('secret_store_id'),
 2391            tags=d.get('tags'),
 2392        )
 2393
 2394
 2395class AuroraMysql:
 2396    '''
 2397
 2398    '''
 2399    __slots__ = [
 2400        'bind_interface',
 2401        'database',
 2402        'egress_filter',
 2403        'healthy',
 2404        'hostname',
 2405        'id',
 2406        'name',
 2407        'password',
 2408        'port',
 2409        'port_override',
 2410        'secret_store_id',
 2411        'tags',
 2412        'username',
 2413    ]
 2414
 2415    def __init__(
 2416        self,
 2417        bind_interface=None,
 2418        database=None,
 2419        egress_filter=None,
 2420        healthy=None,
 2421        hostname=None,
 2422        id=None,
 2423        name=None,
 2424        password=None,
 2425        port=None,
 2426        port_override=None,
 2427        secret_store_id=None,
 2428        tags=None,
 2429        username=None,
 2430    ):
 2431        self.bind_interface = bind_interface if bind_interface is not None else ''
 2432        '''
 2433         Bind interface
 2434        '''
 2435        self.database = database if database is not None else ''
 2436        '''
 2437
 2438        '''
 2439        self.egress_filter = egress_filter if egress_filter is not None else ''
 2440        '''
 2441         A filter applied to the routing logic to pin datasource to nodes.
 2442        '''
 2443        self.healthy = healthy if healthy is not None else False
 2444        '''
 2445         True if the datasource is reachable and the credentials are valid.
 2446        '''
 2447        self.hostname = hostname if hostname is not None else ''
 2448        '''
 2449
 2450        '''
 2451        self.id = id if id is not None else ''
 2452        '''
 2453         Unique identifier of the Resource.
 2454        '''
 2455        self.name = name if name is not None else ''
 2456        '''
 2457         Unique human-readable name of the Resource.
 2458        '''
 2459        self.password = password if password is not None else ''
 2460        '''
 2461
 2462        '''
 2463        self.port = port if port is not None else 0
 2464        '''
 2465
 2466        '''
 2467        self.port_override = port_override if port_override is not None else 0
 2468        '''
 2469
 2470        '''
 2471        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2472        '''
 2473         ID of the secret store containing credentials for this resource, if any.
 2474        '''
 2475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2476        '''
 2477         Tags is a map of key, value pairs.
 2478        '''
 2479        self.username = username if username is not None else ''
 2480        '''
 2481
 2482        '''
 2483
 2484    def __repr__(self):
 2485        return '<sdm.AuroraMysql ' + \
 2486            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2487            'database: ' + repr(self.database) + ' ' +\
 2488            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2489            'healthy: ' + repr(self.healthy) + ' ' +\
 2490            'hostname: ' + repr(self.hostname) + ' ' +\
 2491            'id: ' + repr(self.id) + ' ' +\
 2492            'name: ' + repr(self.name) + ' ' +\
 2493            'password: ' + repr(self.password) + ' ' +\
 2494            'port: ' + repr(self.port) + ' ' +\
 2495            'port_override: ' + repr(self.port_override) + ' ' +\
 2496            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2497            'tags: ' + repr(self.tags) + ' ' +\
 2498            'username: ' + repr(self.username) + ' ' +\
 2499            '>'
 2500
 2501    def to_dict(self):
 2502        return {
 2503            'bind_interface': self.bind_interface,
 2504            'database': self.database,
 2505            'egress_filter': self.egress_filter,
 2506            'healthy': self.healthy,
 2507            'hostname': self.hostname,
 2508            'id': self.id,
 2509            'name': self.name,
 2510            'password': self.password,
 2511            'port': self.port,
 2512            'port_override': self.port_override,
 2513            'secret_store_id': self.secret_store_id,
 2514            'tags': self.tags,
 2515            'username': self.username,
 2516        }
 2517
 2518    @classmethod
 2519    def from_dict(cls, d):
 2520        return cls(
 2521            bind_interface=d.get('bind_interface'),
 2522            database=d.get('database'),
 2523            egress_filter=d.get('egress_filter'),
 2524            healthy=d.get('healthy'),
 2525            hostname=d.get('hostname'),
 2526            id=d.get('id'),
 2527            name=d.get('name'),
 2528            password=d.get('password'),
 2529            port=d.get('port'),
 2530            port_override=d.get('port_override'),
 2531            secret_store_id=d.get('secret_store_id'),
 2532            tags=d.get('tags'),
 2533            username=d.get('username'),
 2534        )
 2535
 2536
 2537class AuroraPostgres:
 2538    '''
 2539
 2540    '''
 2541    __slots__ = [
 2542        'bind_interface',
 2543        'database',
 2544        'egress_filter',
 2545        'healthy',
 2546        'hostname',
 2547        'id',
 2548        'name',
 2549        'override_database',
 2550        'password',
 2551        'port',
 2552        'port_override',
 2553        'secret_store_id',
 2554        'tags',
 2555        'username',
 2556    ]
 2557
 2558    def __init__(
 2559        self,
 2560        bind_interface=None,
 2561        database=None,
 2562        egress_filter=None,
 2563        healthy=None,
 2564        hostname=None,
 2565        id=None,
 2566        name=None,
 2567        override_database=None,
 2568        password=None,
 2569        port=None,
 2570        port_override=None,
 2571        secret_store_id=None,
 2572        tags=None,
 2573        username=None,
 2574    ):
 2575        self.bind_interface = bind_interface if bind_interface is not None else ''
 2576        '''
 2577         Bind interface
 2578        '''
 2579        self.database = database if database is not None else ''
 2580        '''
 2581
 2582        '''
 2583        self.egress_filter = egress_filter if egress_filter is not None else ''
 2584        '''
 2585         A filter applied to the routing logic to pin datasource to nodes.
 2586        '''
 2587        self.healthy = healthy if healthy is not None else False
 2588        '''
 2589         True if the datasource is reachable and the credentials are valid.
 2590        '''
 2591        self.hostname = hostname if hostname is not None else ''
 2592        '''
 2593
 2594        '''
 2595        self.id = id if id is not None else ''
 2596        '''
 2597         Unique identifier of the Resource.
 2598        '''
 2599        self.name = name if name is not None else ''
 2600        '''
 2601         Unique human-readable name of the Resource.
 2602        '''
 2603        self.override_database = override_database if override_database is not None else False
 2604        '''
 2605
 2606        '''
 2607        self.password = password if password is not None else ''
 2608        '''
 2609
 2610        '''
 2611        self.port = port if port is not None else 0
 2612        '''
 2613
 2614        '''
 2615        self.port_override = port_override if port_override is not None else 0
 2616        '''
 2617
 2618        '''
 2619        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2620        '''
 2621         ID of the secret store containing credentials for this resource, if any.
 2622        '''
 2623        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2624        '''
 2625         Tags is a map of key, value pairs.
 2626        '''
 2627        self.username = username if username is not None else ''
 2628        '''
 2629
 2630        '''
 2631
 2632    def __repr__(self):
 2633        return '<sdm.AuroraPostgres ' + \
 2634            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2635            'database: ' + repr(self.database) + ' ' +\
 2636            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2637            'healthy: ' + repr(self.healthy) + ' ' +\
 2638            'hostname: ' + repr(self.hostname) + ' ' +\
 2639            'id: ' + repr(self.id) + ' ' +\
 2640            'name: ' + repr(self.name) + ' ' +\
 2641            'override_database: ' + repr(self.override_database) + ' ' +\
 2642            'password: ' + repr(self.password) + ' ' +\
 2643            'port: ' + repr(self.port) + ' ' +\
 2644            'port_override: ' + repr(self.port_override) + ' ' +\
 2645            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2646            'tags: ' + repr(self.tags) + ' ' +\
 2647            'username: ' + repr(self.username) + ' ' +\
 2648            '>'
 2649
 2650    def to_dict(self):
 2651        return {
 2652            'bind_interface': self.bind_interface,
 2653            'database': self.database,
 2654            'egress_filter': self.egress_filter,
 2655            'healthy': self.healthy,
 2656            'hostname': self.hostname,
 2657            'id': self.id,
 2658            'name': self.name,
 2659            'override_database': self.override_database,
 2660            'password': self.password,
 2661            'port': self.port,
 2662            'port_override': self.port_override,
 2663            'secret_store_id': self.secret_store_id,
 2664            'tags': self.tags,
 2665            'username': self.username,
 2666        }
 2667
 2668    @classmethod
 2669    def from_dict(cls, d):
 2670        return cls(
 2671            bind_interface=d.get('bind_interface'),
 2672            database=d.get('database'),
 2673            egress_filter=d.get('egress_filter'),
 2674            healthy=d.get('healthy'),
 2675            hostname=d.get('hostname'),
 2676            id=d.get('id'),
 2677            name=d.get('name'),
 2678            override_database=d.get('override_database'),
 2679            password=d.get('password'),
 2680            port=d.get('port'),
 2681            port_override=d.get('port_override'),
 2682            secret_store_id=d.get('secret_store_id'),
 2683            tags=d.get('tags'),
 2684            username=d.get('username'),
 2685        )
 2686
 2687
 2688class Azure:
 2689    '''
 2690
 2691    '''
 2692    __slots__ = [
 2693        'app_id',
 2694        'bind_interface',
 2695        'egress_filter',
 2696        'healthy',
 2697        'id',
 2698        'name',
 2699        'password',
 2700        'secret_store_id',
 2701        'tags',
 2702        'tenant_id',
 2703    ]
 2704
 2705    def __init__(
 2706        self,
 2707        app_id=None,
 2708        bind_interface=None,
 2709        egress_filter=None,
 2710        healthy=None,
 2711        id=None,
 2712        name=None,
 2713        password=None,
 2714        secret_store_id=None,
 2715        tags=None,
 2716        tenant_id=None,
 2717    ):
 2718        self.app_id = app_id if app_id is not None else ''
 2719        '''
 2720
 2721        '''
 2722        self.bind_interface = bind_interface if bind_interface is not None else ''
 2723        '''
 2724         Bind interface
 2725        '''
 2726        self.egress_filter = egress_filter if egress_filter is not None else ''
 2727        '''
 2728         A filter applied to the routing logic to pin datasource to nodes.
 2729        '''
 2730        self.healthy = healthy if healthy is not None else False
 2731        '''
 2732         True if the datasource is reachable and the credentials are valid.
 2733        '''
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the Resource.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the Resource.
 2741        '''
 2742        self.password = password if password is not None else ''
 2743        '''
 2744
 2745        '''
 2746        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2747        '''
 2748         ID of the secret store containing credentials for this resource, if any.
 2749        '''
 2750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2751        '''
 2752         Tags is a map of key, value pairs.
 2753        '''
 2754        self.tenant_id = tenant_id if tenant_id is not None else ''
 2755        '''
 2756
 2757        '''
 2758
 2759    def __repr__(self):
 2760        return '<sdm.Azure ' + \
 2761            'app_id: ' + repr(self.app_id) + ' ' +\
 2762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2763            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2764            'healthy: ' + repr(self.healthy) + ' ' +\
 2765            'id: ' + repr(self.id) + ' ' +\
 2766            'name: ' + repr(self.name) + ' ' +\
 2767            'password: ' + repr(self.password) + ' ' +\
 2768            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2769            'tags: ' + repr(self.tags) + ' ' +\
 2770            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2771            '>'
 2772
 2773    def to_dict(self):
 2774        return {
 2775            'app_id': self.app_id,
 2776            'bind_interface': self.bind_interface,
 2777            'egress_filter': self.egress_filter,
 2778            'healthy': self.healthy,
 2779            'id': self.id,
 2780            'name': self.name,
 2781            'password': self.password,
 2782            'secret_store_id': self.secret_store_id,
 2783            'tags': self.tags,
 2784            'tenant_id': self.tenant_id,
 2785        }
 2786
 2787    @classmethod
 2788    def from_dict(cls, d):
 2789        return cls(
 2790            app_id=d.get('app_id'),
 2791            bind_interface=d.get('bind_interface'),
 2792            egress_filter=d.get('egress_filter'),
 2793            healthy=d.get('healthy'),
 2794            id=d.get('id'),
 2795            name=d.get('name'),
 2796            password=d.get('password'),
 2797            secret_store_id=d.get('secret_store_id'),
 2798            tags=d.get('tags'),
 2799            tenant_id=d.get('tenant_id'),
 2800        )
 2801
 2802
 2803class AzureCertificate:
 2804    '''
 2805
 2806    '''
 2807    __slots__ = [
 2808        'app_id',
 2809        'bind_interface',
 2810        'client_certificate',
 2811        'egress_filter',
 2812        'healthy',
 2813        'id',
 2814        'name',
 2815        'secret_store_id',
 2816        'tags',
 2817        'tenant_id',
 2818    ]
 2819
 2820    def __init__(
 2821        self,
 2822        app_id=None,
 2823        bind_interface=None,
 2824        client_certificate=None,
 2825        egress_filter=None,
 2826        healthy=None,
 2827        id=None,
 2828        name=None,
 2829        secret_store_id=None,
 2830        tags=None,
 2831        tenant_id=None,
 2832    ):
 2833        self.app_id = app_id if app_id is not None else ''
 2834        '''
 2835
 2836        '''
 2837        self.bind_interface = bind_interface if bind_interface is not None else ''
 2838        '''
 2839         Bind interface
 2840        '''
 2841        self.client_certificate = client_certificate if client_certificate is not None else ''
 2842        '''
 2843
 2844        '''
 2845        self.egress_filter = egress_filter if egress_filter is not None else ''
 2846        '''
 2847         A filter applied to the routing logic to pin datasource to nodes.
 2848        '''
 2849        self.healthy = healthy if healthy is not None else False
 2850        '''
 2851         True if the datasource is reachable and the credentials are valid.
 2852        '''
 2853        self.id = id if id is not None else ''
 2854        '''
 2855         Unique identifier of the Resource.
 2856        '''
 2857        self.name = name if name is not None else ''
 2858        '''
 2859         Unique human-readable name of the Resource.
 2860        '''
 2861        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2862        '''
 2863         ID of the secret store containing credentials for this resource, if any.
 2864        '''
 2865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2866        '''
 2867         Tags is a map of key, value pairs.
 2868        '''
 2869        self.tenant_id = tenant_id if tenant_id is not None else ''
 2870        '''
 2871
 2872        '''
 2873
 2874    def __repr__(self):
 2875        return '<sdm.AzureCertificate ' + \
 2876            'app_id: ' + repr(self.app_id) + ' ' +\
 2877            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2878            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2879            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2880            'healthy: ' + repr(self.healthy) + ' ' +\
 2881            'id: ' + repr(self.id) + ' ' +\
 2882            'name: ' + repr(self.name) + ' ' +\
 2883            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2884            'tags: ' + repr(self.tags) + ' ' +\
 2885            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2886            '>'
 2887
 2888    def to_dict(self):
 2889        return {
 2890            'app_id': self.app_id,
 2891            'bind_interface': self.bind_interface,
 2892            'client_certificate': self.client_certificate,
 2893            'egress_filter': self.egress_filter,
 2894            'healthy': self.healthy,
 2895            'id': self.id,
 2896            'name': self.name,
 2897            'secret_store_id': self.secret_store_id,
 2898            'tags': self.tags,
 2899            'tenant_id': self.tenant_id,
 2900        }
 2901
 2902    @classmethod
 2903    def from_dict(cls, d):
 2904        return cls(
 2905            app_id=d.get('app_id'),
 2906            bind_interface=d.get('bind_interface'),
 2907            client_certificate=d.get('client_certificate'),
 2908            egress_filter=d.get('egress_filter'),
 2909            healthy=d.get('healthy'),
 2910            id=d.get('id'),
 2911            name=d.get('name'),
 2912            secret_store_id=d.get('secret_store_id'),
 2913            tags=d.get('tags'),
 2914            tenant_id=d.get('tenant_id'),
 2915        )
 2916
 2917
 2918class AzurePostgres:
 2919    '''
 2920
 2921    '''
 2922    __slots__ = [
 2923        'bind_interface',
 2924        'database',
 2925        'egress_filter',
 2926        'healthy',
 2927        'hostname',
 2928        'id',
 2929        'name',
 2930        'override_database',
 2931        'password',
 2932        'port',
 2933        'port_override',
 2934        'secret_store_id',
 2935        'tags',
 2936        'username',
 2937    ]
 2938
 2939    def __init__(
 2940        self,
 2941        bind_interface=None,
 2942        database=None,
 2943        egress_filter=None,
 2944        healthy=None,
 2945        hostname=None,
 2946        id=None,
 2947        name=None,
 2948        override_database=None,
 2949        password=None,
 2950        port=None,
 2951        port_override=None,
 2952        secret_store_id=None,
 2953        tags=None,
 2954        username=None,
 2955    ):
 2956        self.bind_interface = bind_interface if bind_interface is not None else ''
 2957        '''
 2958         Bind interface
 2959        '''
 2960        self.database = database if database is not None else ''
 2961        '''
 2962
 2963        '''
 2964        self.egress_filter = egress_filter if egress_filter is not None else ''
 2965        '''
 2966         A filter applied to the routing logic to pin datasource to nodes.
 2967        '''
 2968        self.healthy = healthy if healthy is not None else False
 2969        '''
 2970         True if the datasource is reachable and the credentials are valid.
 2971        '''
 2972        self.hostname = hostname if hostname is not None else ''
 2973        '''
 2974
 2975        '''
 2976        self.id = id if id is not None else ''
 2977        '''
 2978         Unique identifier of the Resource.
 2979        '''
 2980        self.name = name if name is not None else ''
 2981        '''
 2982         Unique human-readable name of the Resource.
 2983        '''
 2984        self.override_database = override_database if override_database is not None else False
 2985        '''
 2986
 2987        '''
 2988        self.password = password if password is not None else ''
 2989        '''
 2990
 2991        '''
 2992        self.port = port if port is not None else 0
 2993        '''
 2994
 2995        '''
 2996        self.port_override = port_override if port_override is not None else 0
 2997        '''
 2998
 2999        '''
 3000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3001        '''
 3002         ID of the secret store containing credentials for this resource, if any.
 3003        '''
 3004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3005        '''
 3006         Tags is a map of key, value pairs.
 3007        '''
 3008        self.username = username if username is not None else ''
 3009        '''
 3010
 3011        '''
 3012
 3013    def __repr__(self):
 3014        return '<sdm.AzurePostgres ' + \
 3015            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3016            'database: ' + repr(self.database) + ' ' +\
 3017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3018            'healthy: ' + repr(self.healthy) + ' ' +\
 3019            'hostname: ' + repr(self.hostname) + ' ' +\
 3020            'id: ' + repr(self.id) + ' ' +\
 3021            'name: ' + repr(self.name) + ' ' +\
 3022            'override_database: ' + repr(self.override_database) + ' ' +\
 3023            'password: ' + repr(self.password) + ' ' +\
 3024            'port: ' + repr(self.port) + ' ' +\
 3025            'port_override: ' + repr(self.port_override) + ' ' +\
 3026            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3027            'tags: ' + repr(self.tags) + ' ' +\
 3028            'username: ' + repr(self.username) + ' ' +\
 3029            '>'
 3030
 3031    def to_dict(self):
 3032        return {
 3033            'bind_interface': self.bind_interface,
 3034            'database': self.database,
 3035            'egress_filter': self.egress_filter,
 3036            'healthy': self.healthy,
 3037            'hostname': self.hostname,
 3038            'id': self.id,
 3039            'name': self.name,
 3040            'override_database': self.override_database,
 3041            'password': self.password,
 3042            'port': self.port,
 3043            'port_override': self.port_override,
 3044            'secret_store_id': self.secret_store_id,
 3045            'tags': self.tags,
 3046            'username': self.username,
 3047        }
 3048
 3049    @classmethod
 3050    def from_dict(cls, d):
 3051        return cls(
 3052            bind_interface=d.get('bind_interface'),
 3053            database=d.get('database'),
 3054            egress_filter=d.get('egress_filter'),
 3055            healthy=d.get('healthy'),
 3056            hostname=d.get('hostname'),
 3057            id=d.get('id'),
 3058            name=d.get('name'),
 3059            override_database=d.get('override_database'),
 3060            password=d.get('password'),
 3061            port=d.get('port'),
 3062            port_override=d.get('port_override'),
 3063            secret_store_id=d.get('secret_store_id'),
 3064            tags=d.get('tags'),
 3065            username=d.get('username'),
 3066        )
 3067
 3068
 3069class AzureStore:
 3070    '''
 3071
 3072    '''
 3073    __slots__ = [
 3074        'id',
 3075        'name',
 3076        'tags',
 3077        'vault_uri',
 3078    ]
 3079
 3080    def __init__(
 3081        self,
 3082        id=None,
 3083        name=None,
 3084        tags=None,
 3085        vault_uri=None,
 3086    ):
 3087        self.id = id if id is not None else ''
 3088        '''
 3089         Unique identifier of the SecretStore.
 3090        '''
 3091        self.name = name if name is not None else ''
 3092        '''
 3093         Unique human-readable name of the SecretStore.
 3094        '''
 3095        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3096        '''
 3097         Tags is a map of key, value pairs.
 3098        '''
 3099        self.vault_uri = vault_uri if vault_uri is not None else ''
 3100        '''
 3101
 3102        '''
 3103
 3104    def __repr__(self):
 3105        return '<sdm.AzureStore ' + \
 3106            'id: ' + repr(self.id) + ' ' +\
 3107            'name: ' + repr(self.name) + ' ' +\
 3108            'tags: ' + repr(self.tags) + ' ' +\
 3109            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3110            '>'
 3111
 3112    def to_dict(self):
 3113        return {
 3114            'id': self.id,
 3115            'name': self.name,
 3116            'tags': self.tags,
 3117            'vault_uri': self.vault_uri,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            id=d.get('id'),
 3124            name=d.get('name'),
 3125            tags=d.get('tags'),
 3126            vault_uri=d.get('vault_uri'),
 3127        )
 3128
 3129
 3130class BigQuery:
 3131    '''
 3132
 3133    '''
 3134    __slots__ = [
 3135        'bind_interface',
 3136        'egress_filter',
 3137        'endpoint',
 3138        'healthy',
 3139        'id',
 3140        'name',
 3141        'port_override',
 3142        'private_key',
 3143        'project',
 3144        'secret_store_id',
 3145        'tags',
 3146        'username',
 3147    ]
 3148
 3149    def __init__(
 3150        self,
 3151        bind_interface=None,
 3152        egress_filter=None,
 3153        endpoint=None,
 3154        healthy=None,
 3155        id=None,
 3156        name=None,
 3157        port_override=None,
 3158        private_key=None,
 3159        project=None,
 3160        secret_store_id=None,
 3161        tags=None,
 3162        username=None,
 3163    ):
 3164        self.bind_interface = bind_interface if bind_interface is not None else ''
 3165        '''
 3166         Bind interface
 3167        '''
 3168        self.egress_filter = egress_filter if egress_filter is not None else ''
 3169        '''
 3170         A filter applied to the routing logic to pin datasource to nodes.
 3171        '''
 3172        self.endpoint = endpoint if endpoint is not None else ''
 3173        '''
 3174
 3175        '''
 3176        self.healthy = healthy if healthy is not None else False
 3177        '''
 3178         True if the datasource is reachable and the credentials are valid.
 3179        '''
 3180        self.id = id if id is not None else ''
 3181        '''
 3182         Unique identifier of the Resource.
 3183        '''
 3184        self.name = name if name is not None else ''
 3185        '''
 3186         Unique human-readable name of the Resource.
 3187        '''
 3188        self.port_override = port_override if port_override is not None else 0
 3189        '''
 3190
 3191        '''
 3192        self.private_key = private_key if private_key is not None else ''
 3193        '''
 3194
 3195        '''
 3196        self.project = project if project is not None else ''
 3197        '''
 3198
 3199        '''
 3200        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3201        '''
 3202         ID of the secret store containing credentials for this resource, if any.
 3203        '''
 3204        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3205        '''
 3206         Tags is a map of key, value pairs.
 3207        '''
 3208        self.username = username if username is not None else ''
 3209        '''
 3210
 3211        '''
 3212
 3213    def __repr__(self):
 3214        return '<sdm.BigQuery ' + \
 3215            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3216            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3217            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3218            'healthy: ' + repr(self.healthy) + ' ' +\
 3219            'id: ' + repr(self.id) + ' ' +\
 3220            'name: ' + repr(self.name) + ' ' +\
 3221            'port_override: ' + repr(self.port_override) + ' ' +\
 3222            'private_key: ' + repr(self.private_key) + ' ' +\
 3223            'project: ' + repr(self.project) + ' ' +\
 3224            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3225            'tags: ' + repr(self.tags) + ' ' +\
 3226            'username: ' + repr(self.username) + ' ' +\
 3227            '>'
 3228
 3229    def to_dict(self):
 3230        return {
 3231            'bind_interface': self.bind_interface,
 3232            'egress_filter': self.egress_filter,
 3233            'endpoint': self.endpoint,
 3234            'healthy': self.healthy,
 3235            'id': self.id,
 3236            'name': self.name,
 3237            'port_override': self.port_override,
 3238            'private_key': self.private_key,
 3239            'project': self.project,
 3240            'secret_store_id': self.secret_store_id,
 3241            'tags': self.tags,
 3242            'username': self.username,
 3243        }
 3244
 3245    @classmethod
 3246    def from_dict(cls, d):
 3247        return cls(
 3248            bind_interface=d.get('bind_interface'),
 3249            egress_filter=d.get('egress_filter'),
 3250            endpoint=d.get('endpoint'),
 3251            healthy=d.get('healthy'),
 3252            id=d.get('id'),
 3253            name=d.get('name'),
 3254            port_override=d.get('port_override'),
 3255            private_key=d.get('private_key'),
 3256            project=d.get('project'),
 3257            secret_store_id=d.get('secret_store_id'),
 3258            tags=d.get('tags'),
 3259            username=d.get('username'),
 3260        )
 3261
 3262
 3263class Cassandra:
 3264    '''
 3265
 3266    '''
 3267    __slots__ = [
 3268        'bind_interface',
 3269        'egress_filter',
 3270        'healthy',
 3271        'hostname',
 3272        'id',
 3273        'name',
 3274        'password',
 3275        'port',
 3276        'port_override',
 3277        'secret_store_id',
 3278        'tags',
 3279        'tls_required',
 3280        'username',
 3281    ]
 3282
 3283    def __init__(
 3284        self,
 3285        bind_interface=None,
 3286        egress_filter=None,
 3287        healthy=None,
 3288        hostname=None,
 3289        id=None,
 3290        name=None,
 3291        password=None,
 3292        port=None,
 3293        port_override=None,
 3294        secret_store_id=None,
 3295        tags=None,
 3296        tls_required=None,
 3297        username=None,
 3298    ):
 3299        self.bind_interface = bind_interface if bind_interface is not None else ''
 3300        '''
 3301         Bind interface
 3302        '''
 3303        self.egress_filter = egress_filter if egress_filter is not None else ''
 3304        '''
 3305         A filter applied to the routing logic to pin datasource to nodes.
 3306        '''
 3307        self.healthy = healthy if healthy is not None else False
 3308        '''
 3309         True if the datasource is reachable and the credentials are valid.
 3310        '''
 3311        self.hostname = hostname if hostname is not None else ''
 3312        '''
 3313
 3314        '''
 3315        self.id = id if id is not None else ''
 3316        '''
 3317         Unique identifier of the Resource.
 3318        '''
 3319        self.name = name if name is not None else ''
 3320        '''
 3321         Unique human-readable name of the Resource.
 3322        '''
 3323        self.password = password if password is not None else ''
 3324        '''
 3325
 3326        '''
 3327        self.port = port if port is not None else 0
 3328        '''
 3329
 3330        '''
 3331        self.port_override = port_override if port_override is not None else 0
 3332        '''
 3333
 3334        '''
 3335        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3336        '''
 3337         ID of the secret store containing credentials for this resource, if any.
 3338        '''
 3339        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3340        '''
 3341         Tags is a map of key, value pairs.
 3342        '''
 3343        self.tls_required = tls_required if tls_required is not None else False
 3344        '''
 3345
 3346        '''
 3347        self.username = username if username is not None else ''
 3348        '''
 3349
 3350        '''
 3351
 3352    def __repr__(self):
 3353        return '<sdm.Cassandra ' + \
 3354            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3355            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3356            'healthy: ' + repr(self.healthy) + ' ' +\
 3357            'hostname: ' + repr(self.hostname) + ' ' +\
 3358            'id: ' + repr(self.id) + ' ' +\
 3359            'name: ' + repr(self.name) + ' ' +\
 3360            'password: ' + repr(self.password) + ' ' +\
 3361            'port: ' + repr(self.port) + ' ' +\
 3362            'port_override: ' + repr(self.port_override) + ' ' +\
 3363            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3364            'tags: ' + repr(self.tags) + ' ' +\
 3365            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3366            'username: ' + repr(self.username) + ' ' +\
 3367            '>'
 3368
 3369    def to_dict(self):
 3370        return {
 3371            'bind_interface': self.bind_interface,
 3372            'egress_filter': self.egress_filter,
 3373            'healthy': self.healthy,
 3374            'hostname': self.hostname,
 3375            'id': self.id,
 3376            'name': self.name,
 3377            'password': self.password,
 3378            'port': self.port,
 3379            'port_override': self.port_override,
 3380            'secret_store_id': self.secret_store_id,
 3381            'tags': self.tags,
 3382            'tls_required': self.tls_required,
 3383            'username': self.username,
 3384        }
 3385
 3386    @classmethod
 3387    def from_dict(cls, d):
 3388        return cls(
 3389            bind_interface=d.get('bind_interface'),
 3390            egress_filter=d.get('egress_filter'),
 3391            healthy=d.get('healthy'),
 3392            hostname=d.get('hostname'),
 3393            id=d.get('id'),
 3394            name=d.get('name'),
 3395            password=d.get('password'),
 3396            port=d.get('port'),
 3397            port_override=d.get('port_override'),
 3398            secret_store_id=d.get('secret_store_id'),
 3399            tags=d.get('tags'),
 3400            tls_required=d.get('tls_required'),
 3401            username=d.get('username'),
 3402        )
 3403
 3404
 3405class Citus:
 3406    '''
 3407
 3408    '''
 3409    __slots__ = [
 3410        'bind_interface',
 3411        'database',
 3412        'egress_filter',
 3413        'healthy',
 3414        'hostname',
 3415        'id',
 3416        'name',
 3417        'override_database',
 3418        'password',
 3419        'port',
 3420        'port_override',
 3421        'secret_store_id',
 3422        'tags',
 3423        'username',
 3424    ]
 3425
 3426    def __init__(
 3427        self,
 3428        bind_interface=None,
 3429        database=None,
 3430        egress_filter=None,
 3431        healthy=None,
 3432        hostname=None,
 3433        id=None,
 3434        name=None,
 3435        override_database=None,
 3436        password=None,
 3437        port=None,
 3438        port_override=None,
 3439        secret_store_id=None,
 3440        tags=None,
 3441        username=None,
 3442    ):
 3443        self.bind_interface = bind_interface if bind_interface is not None else ''
 3444        '''
 3445         Bind interface
 3446        '''
 3447        self.database = database if database is not None else ''
 3448        '''
 3449
 3450        '''
 3451        self.egress_filter = egress_filter if egress_filter is not None else ''
 3452        '''
 3453         A filter applied to the routing logic to pin datasource to nodes.
 3454        '''
 3455        self.healthy = healthy if healthy is not None else False
 3456        '''
 3457         True if the datasource is reachable and the credentials are valid.
 3458        '''
 3459        self.hostname = hostname if hostname is not None else ''
 3460        '''
 3461
 3462        '''
 3463        self.id = id if id is not None else ''
 3464        '''
 3465         Unique identifier of the Resource.
 3466        '''
 3467        self.name = name if name is not None else ''
 3468        '''
 3469         Unique human-readable name of the Resource.
 3470        '''
 3471        self.override_database = override_database if override_database is not None else False
 3472        '''
 3473
 3474        '''
 3475        self.password = password if password is not None else ''
 3476        '''
 3477
 3478        '''
 3479        self.port = port if port is not None else 0
 3480        '''
 3481
 3482        '''
 3483        self.port_override = port_override if port_override is not None else 0
 3484        '''
 3485
 3486        '''
 3487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3488        '''
 3489         ID of the secret store containing credentials for this resource, if any.
 3490        '''
 3491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3492        '''
 3493         Tags is a map of key, value pairs.
 3494        '''
 3495        self.username = username if username is not None else ''
 3496        '''
 3497
 3498        '''
 3499
 3500    def __repr__(self):
 3501        return '<sdm.Citus ' + \
 3502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3503            'database: ' + repr(self.database) + ' ' +\
 3504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3505            'healthy: ' + repr(self.healthy) + ' ' +\
 3506            'hostname: ' + repr(self.hostname) + ' ' +\
 3507            'id: ' + repr(self.id) + ' ' +\
 3508            'name: ' + repr(self.name) + ' ' +\
 3509            'override_database: ' + repr(self.override_database) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'bind_interface': self.bind_interface,
 3521            'database': self.database,
 3522            'egress_filter': self.egress_filter,
 3523            'healthy': self.healthy,
 3524            'hostname': self.hostname,
 3525            'id': self.id,
 3526            'name': self.name,
 3527            'override_database': self.override_database,
 3528            'password': self.password,
 3529            'port': self.port,
 3530            'port_override': self.port_override,
 3531            'secret_store_id': self.secret_store_id,
 3532            'tags': self.tags,
 3533            'username': self.username,
 3534        }
 3535
 3536    @classmethod
 3537    def from_dict(cls, d):
 3538        return cls(
 3539            bind_interface=d.get('bind_interface'),
 3540            database=d.get('database'),
 3541            egress_filter=d.get('egress_filter'),
 3542            healthy=d.get('healthy'),
 3543            hostname=d.get('hostname'),
 3544            id=d.get('id'),
 3545            name=d.get('name'),
 3546            override_database=d.get('override_database'),
 3547            password=d.get('password'),
 3548            port=d.get('port'),
 3549            port_override=d.get('port_override'),
 3550            secret_store_id=d.get('secret_store_id'),
 3551            tags=d.get('tags'),
 3552            username=d.get('username'),
 3553        )
 3554
 3555
 3556class Clustrix:
 3557    '''
 3558
 3559    '''
 3560    __slots__ = [
 3561        'bind_interface',
 3562        'database',
 3563        'egress_filter',
 3564        'healthy',
 3565        'hostname',
 3566        'id',
 3567        'name',
 3568        'password',
 3569        'port',
 3570        'port_override',
 3571        'secret_store_id',
 3572        'tags',
 3573        'username',
 3574    ]
 3575
 3576    def __init__(
 3577        self,
 3578        bind_interface=None,
 3579        database=None,
 3580        egress_filter=None,
 3581        healthy=None,
 3582        hostname=None,
 3583        id=None,
 3584        name=None,
 3585        password=None,
 3586        port=None,
 3587        port_override=None,
 3588        secret_store_id=None,
 3589        tags=None,
 3590        username=None,
 3591    ):
 3592        self.bind_interface = bind_interface if bind_interface is not None else ''
 3593        '''
 3594         Bind interface
 3595        '''
 3596        self.database = database if database is not None else ''
 3597        '''
 3598
 3599        '''
 3600        self.egress_filter = egress_filter if egress_filter is not None else ''
 3601        '''
 3602         A filter applied to the routing logic to pin datasource to nodes.
 3603        '''
 3604        self.healthy = healthy if healthy is not None else False
 3605        '''
 3606         True if the datasource is reachable and the credentials are valid.
 3607        '''
 3608        self.hostname = hostname if hostname is not None else ''
 3609        '''
 3610
 3611        '''
 3612        self.id = id if id is not None else ''
 3613        '''
 3614         Unique identifier of the Resource.
 3615        '''
 3616        self.name = name if name is not None else ''
 3617        '''
 3618         Unique human-readable name of the Resource.
 3619        '''
 3620        self.password = password if password is not None else ''
 3621        '''
 3622
 3623        '''
 3624        self.port = port if port is not None else 0
 3625        '''
 3626
 3627        '''
 3628        self.port_override = port_override if port_override is not None else 0
 3629        '''
 3630
 3631        '''
 3632        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3633        '''
 3634         ID of the secret store containing credentials for this resource, if any.
 3635        '''
 3636        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3637        '''
 3638         Tags is a map of key, value pairs.
 3639        '''
 3640        self.username = username if username is not None else ''
 3641        '''
 3642
 3643        '''
 3644
 3645    def __repr__(self):
 3646        return '<sdm.Clustrix ' + \
 3647            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3648            'database: ' + repr(self.database) + ' ' +\
 3649            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3650            'healthy: ' + repr(self.healthy) + ' ' +\
 3651            'hostname: ' + repr(self.hostname) + ' ' +\
 3652            'id: ' + repr(self.id) + ' ' +\
 3653            'name: ' + repr(self.name) + ' ' +\
 3654            'password: ' + repr(self.password) + ' ' +\
 3655            'port: ' + repr(self.port) + ' ' +\
 3656            'port_override: ' + repr(self.port_override) + ' ' +\
 3657            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3658            'tags: ' + repr(self.tags) + ' ' +\
 3659            'username: ' + repr(self.username) + ' ' +\
 3660            '>'
 3661
 3662    def to_dict(self):
 3663        return {
 3664            'bind_interface': self.bind_interface,
 3665            'database': self.database,
 3666            'egress_filter': self.egress_filter,
 3667            'healthy': self.healthy,
 3668            'hostname': self.hostname,
 3669            'id': self.id,
 3670            'name': self.name,
 3671            'password': self.password,
 3672            'port': self.port,
 3673            'port_override': self.port_override,
 3674            'secret_store_id': self.secret_store_id,
 3675            'tags': self.tags,
 3676            'username': self.username,
 3677        }
 3678
 3679    @classmethod
 3680    def from_dict(cls, d):
 3681        return cls(
 3682            bind_interface=d.get('bind_interface'),
 3683            database=d.get('database'),
 3684            egress_filter=d.get('egress_filter'),
 3685            healthy=d.get('healthy'),
 3686            hostname=d.get('hostname'),
 3687            id=d.get('id'),
 3688            name=d.get('name'),
 3689            password=d.get('password'),
 3690            port=d.get('port'),
 3691            port_override=d.get('port_override'),
 3692            secret_store_id=d.get('secret_store_id'),
 3693            tags=d.get('tags'),
 3694            username=d.get('username'),
 3695        )
 3696
 3697
 3698class Cockroach:
 3699    '''
 3700
 3701    '''
 3702    __slots__ = [
 3703        'bind_interface',
 3704        'database',
 3705        'egress_filter',
 3706        'healthy',
 3707        'hostname',
 3708        'id',
 3709        'name',
 3710        'override_database',
 3711        'password',
 3712        'port',
 3713        'port_override',
 3714        'secret_store_id',
 3715        'tags',
 3716        'username',
 3717    ]
 3718
 3719    def __init__(
 3720        self,
 3721        bind_interface=None,
 3722        database=None,
 3723        egress_filter=None,
 3724        healthy=None,
 3725        hostname=None,
 3726        id=None,
 3727        name=None,
 3728        override_database=None,
 3729        password=None,
 3730        port=None,
 3731        port_override=None,
 3732        secret_store_id=None,
 3733        tags=None,
 3734        username=None,
 3735    ):
 3736        self.bind_interface = bind_interface if bind_interface is not None else ''
 3737        '''
 3738         Bind interface
 3739        '''
 3740        self.database = database if database is not None else ''
 3741        '''
 3742
 3743        '''
 3744        self.egress_filter = egress_filter if egress_filter is not None else ''
 3745        '''
 3746         A filter applied to the routing logic to pin datasource to nodes.
 3747        '''
 3748        self.healthy = healthy if healthy is not None else False
 3749        '''
 3750         True if the datasource is reachable and the credentials are valid.
 3751        '''
 3752        self.hostname = hostname if hostname is not None else ''
 3753        '''
 3754
 3755        '''
 3756        self.id = id if id is not None else ''
 3757        '''
 3758         Unique identifier of the Resource.
 3759        '''
 3760        self.name = name if name is not None else ''
 3761        '''
 3762         Unique human-readable name of the Resource.
 3763        '''
 3764        self.override_database = override_database if override_database is not None else False
 3765        '''
 3766
 3767        '''
 3768        self.password = password if password is not None else ''
 3769        '''
 3770
 3771        '''
 3772        self.port = port if port is not None else 0
 3773        '''
 3774
 3775        '''
 3776        self.port_override = port_override if port_override is not None else 0
 3777        '''
 3778
 3779        '''
 3780        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3781        '''
 3782         ID of the secret store containing credentials for this resource, if any.
 3783        '''
 3784        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3785        '''
 3786         Tags is a map of key, value pairs.
 3787        '''
 3788        self.username = username if username is not None else ''
 3789        '''
 3790
 3791        '''
 3792
 3793    def __repr__(self):
 3794        return '<sdm.Cockroach ' + \
 3795            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3796            'database: ' + repr(self.database) + ' ' +\
 3797            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3798            'healthy: ' + repr(self.healthy) + ' ' +\
 3799            'hostname: ' + repr(self.hostname) + ' ' +\
 3800            'id: ' + repr(self.id) + ' ' +\
 3801            'name: ' + repr(self.name) + ' ' +\
 3802            'override_database: ' + repr(self.override_database) + ' ' +\
 3803            'password: ' + repr(self.password) + ' ' +\
 3804            'port: ' + repr(self.port) + ' ' +\
 3805            'port_override: ' + repr(self.port_override) + ' ' +\
 3806            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3807            'tags: ' + repr(self.tags) + ' ' +\
 3808            'username: ' + repr(self.username) + ' ' +\
 3809            '>'
 3810
 3811    def to_dict(self):
 3812        return {
 3813            'bind_interface': self.bind_interface,
 3814            'database': self.database,
 3815            'egress_filter': self.egress_filter,
 3816            'healthy': self.healthy,
 3817            'hostname': self.hostname,
 3818            'id': self.id,
 3819            'name': self.name,
 3820            'override_database': self.override_database,
 3821            'password': self.password,
 3822            'port': self.port,
 3823            'port_override': self.port_override,
 3824            'secret_store_id': self.secret_store_id,
 3825            'tags': self.tags,
 3826            'username': self.username,
 3827        }
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls(
 3832            bind_interface=d.get('bind_interface'),
 3833            database=d.get('database'),
 3834            egress_filter=d.get('egress_filter'),
 3835            healthy=d.get('healthy'),
 3836            hostname=d.get('hostname'),
 3837            id=d.get('id'),
 3838            name=d.get('name'),
 3839            override_database=d.get('override_database'),
 3840            password=d.get('password'),
 3841            port=d.get('port'),
 3842            port_override=d.get('port_override'),
 3843            secret_store_id=d.get('secret_store_id'),
 3844            tags=d.get('tags'),
 3845            username=d.get('username'),
 3846        )
 3847
 3848
 3849class ControlPanelGetSSHCAPublicKeyResponse:
 3850    '''
 3851     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3852     organization's SSH Certificate Authority public key.
 3853    '''
 3854    __slots__ = [
 3855        'meta',
 3856        'public_key',
 3857        'rate_limit',
 3858    ]
 3859
 3860    def __init__(
 3861        self,
 3862        meta=None,
 3863        public_key=None,
 3864        rate_limit=None,
 3865    ):
 3866        self.meta = meta if meta is not None else None
 3867        '''
 3868         Reserved for future use.
 3869        '''
 3870        self.public_key = public_key if public_key is not None else ''
 3871        '''
 3872         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3873         key format.
 3874        '''
 3875        self.rate_limit = rate_limit if rate_limit is not None else None
 3876        '''
 3877         Rate limit information.
 3878        '''
 3879
 3880    def __repr__(self):
 3881        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3882            'meta: ' + repr(self.meta) + ' ' +\
 3883            'public_key: ' + repr(self.public_key) + ' ' +\
 3884            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3885            '>'
 3886
 3887    def to_dict(self):
 3888        return {
 3889            'meta': self.meta,
 3890            'public_key': self.public_key,
 3891            'rate_limit': self.rate_limit,
 3892        }
 3893
 3894    @classmethod
 3895    def from_dict(cls, d):
 3896        return cls(
 3897            meta=d.get('meta'),
 3898            public_key=d.get('public_key'),
 3899            rate_limit=d.get('rate_limit'),
 3900        )
 3901
 3902
 3903class ControlPanelVerifyJWTResponse:
 3904    '''
 3905     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3906    '''
 3907    __slots__ = [
 3908        'meta',
 3909        'rate_limit',
 3910        'valid',
 3911    ]
 3912
 3913    def __init__(
 3914        self,
 3915        meta=None,
 3916        rate_limit=None,
 3917        valid=None,
 3918    ):
 3919        self.meta = meta if meta is not None else None
 3920        '''
 3921         Reserved for future use.
 3922        '''
 3923        self.rate_limit = rate_limit if rate_limit is not None else None
 3924        '''
 3925         Rate limit information.
 3926        '''
 3927        self.valid = valid if valid is not None else False
 3928        '''
 3929         Reports if the given token is valid.
 3930        '''
 3931
 3932    def __repr__(self):
 3933        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3934            'meta: ' + repr(self.meta) + ' ' +\
 3935            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3936            'valid: ' + repr(self.valid) + ' ' +\
 3937            '>'
 3938
 3939    def to_dict(self):
 3940        return {
 3941            'meta': self.meta,
 3942            'rate_limit': self.rate_limit,
 3943            'valid': self.valid,
 3944        }
 3945
 3946    @classmethod
 3947    def from_dict(cls, d):
 3948        return cls(
 3949            meta=d.get('meta'),
 3950            rate_limit=d.get('rate_limit'),
 3951            valid=d.get('valid'),
 3952        )
 3953
 3954
 3955class CreateResponseMetadata:
 3956    '''
 3957     CreateResponseMetadata is reserved for future use.
 3958    '''
 3959    __slots__ = []
 3960
 3961    def __init__(self, ):
 3962        pass
 3963
 3964    def __repr__(self):
 3965        return '<sdm.CreateResponseMetadata ' + \
 3966            '>'
 3967
 3968    def to_dict(self):
 3969        return {}
 3970
 3971    @classmethod
 3972    def from_dict(cls, d):
 3973        return cls()
 3974
 3975
 3976class DB2I:
 3977    '''
 3978
 3979    '''
 3980    __slots__ = [
 3981        'bind_interface',
 3982        'egress_filter',
 3983        'healthy',
 3984        'hostname',
 3985        'id',
 3986        'name',
 3987        'password',
 3988        'port',
 3989        'port_override',
 3990        'secret_store_id',
 3991        'tags',
 3992        'tls_required',
 3993        'username',
 3994    ]
 3995
 3996    def __init__(
 3997        self,
 3998        bind_interface=None,
 3999        egress_filter=None,
 4000        healthy=None,
 4001        hostname=None,
 4002        id=None,
 4003        name=None,
 4004        password=None,
 4005        port=None,
 4006        port_override=None,
 4007        secret_store_id=None,
 4008        tags=None,
 4009        tls_required=None,
 4010        username=None,
 4011    ):
 4012        self.bind_interface = bind_interface if bind_interface is not None else ''
 4013        '''
 4014         Bind interface
 4015        '''
 4016        self.egress_filter = egress_filter if egress_filter is not None else ''
 4017        '''
 4018         A filter applied to the routing logic to pin datasource to nodes.
 4019        '''
 4020        self.healthy = healthy if healthy is not None else False
 4021        '''
 4022         True if the datasource is reachable and the credentials are valid.
 4023        '''
 4024        self.hostname = hostname if hostname is not None else ''
 4025        '''
 4026
 4027        '''
 4028        self.id = id if id is not None else ''
 4029        '''
 4030         Unique identifier of the Resource.
 4031        '''
 4032        self.name = name if name is not None else ''
 4033        '''
 4034         Unique human-readable name of the Resource.
 4035        '''
 4036        self.password = password if password is not None else ''
 4037        '''
 4038
 4039        '''
 4040        self.port = port if port is not None else 0
 4041        '''
 4042
 4043        '''
 4044        self.port_override = port_override if port_override is not None else 0
 4045        '''
 4046
 4047        '''
 4048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4049        '''
 4050         ID of the secret store containing credentials for this resource, if any.
 4051        '''
 4052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4053        '''
 4054         Tags is a map of key, value pairs.
 4055        '''
 4056        self.tls_required = tls_required if tls_required is not None else False
 4057        '''
 4058
 4059        '''
 4060        self.username = username if username is not None else ''
 4061        '''
 4062
 4063        '''
 4064
 4065    def __repr__(self):
 4066        return '<sdm.DB2I ' + \
 4067            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4068            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4069            'healthy: ' + repr(self.healthy) + ' ' +\
 4070            'hostname: ' + repr(self.hostname) + ' ' +\
 4071            'id: ' + repr(self.id) + ' ' +\
 4072            'name: ' + repr(self.name) + ' ' +\
 4073            'password: ' + repr(self.password) + ' ' +\
 4074            'port: ' + repr(self.port) + ' ' +\
 4075            'port_override: ' + repr(self.port_override) + ' ' +\
 4076            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4077            'tags: ' + repr(self.tags) + ' ' +\
 4078            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4079            'username: ' + repr(self.username) + ' ' +\
 4080            '>'
 4081
 4082    def to_dict(self):
 4083        return {
 4084            'bind_interface': self.bind_interface,
 4085            'egress_filter': self.egress_filter,
 4086            'healthy': self.healthy,
 4087            'hostname': self.hostname,
 4088            'id': self.id,
 4089            'name': self.name,
 4090            'password': self.password,
 4091            'port': self.port,
 4092            'port_override': self.port_override,
 4093            'secret_store_id': self.secret_store_id,
 4094            'tags': self.tags,
 4095            'tls_required': self.tls_required,
 4096            'username': self.username,
 4097        }
 4098
 4099    @classmethod
 4100    def from_dict(cls, d):
 4101        return cls(
 4102            bind_interface=d.get('bind_interface'),
 4103            egress_filter=d.get('egress_filter'),
 4104            healthy=d.get('healthy'),
 4105            hostname=d.get('hostname'),
 4106            id=d.get('id'),
 4107            name=d.get('name'),
 4108            password=d.get('password'),
 4109            port=d.get('port'),
 4110            port_override=d.get('port_override'),
 4111            secret_store_id=d.get('secret_store_id'),
 4112            tags=d.get('tags'),
 4113            tls_required=d.get('tls_required'),
 4114            username=d.get('username'),
 4115        )
 4116
 4117
 4118class DB2LUW:
 4119    '''
 4120
 4121    '''
 4122    __slots__ = [
 4123        'bind_interface',
 4124        'database',
 4125        'egress_filter',
 4126        'healthy',
 4127        'hostname',
 4128        'id',
 4129        'name',
 4130        'password',
 4131        'port',
 4132        'port_override',
 4133        'secret_store_id',
 4134        'tags',
 4135        'username',
 4136    ]
 4137
 4138    def __init__(
 4139        self,
 4140        bind_interface=None,
 4141        database=None,
 4142        egress_filter=None,
 4143        healthy=None,
 4144        hostname=None,
 4145        id=None,
 4146        name=None,
 4147        password=None,
 4148        port=None,
 4149        port_override=None,
 4150        secret_store_id=None,
 4151        tags=None,
 4152        username=None,
 4153    ):
 4154        self.bind_interface = bind_interface if bind_interface is not None else ''
 4155        '''
 4156         Bind interface
 4157        '''
 4158        self.database = database if database is not None else ''
 4159        '''
 4160
 4161        '''
 4162        self.egress_filter = egress_filter if egress_filter is not None else ''
 4163        '''
 4164         A filter applied to the routing logic to pin datasource to nodes.
 4165        '''
 4166        self.healthy = healthy if healthy is not None else False
 4167        '''
 4168         True if the datasource is reachable and the credentials are valid.
 4169        '''
 4170        self.hostname = hostname if hostname is not None else ''
 4171        '''
 4172
 4173        '''
 4174        self.id = id if id is not None else ''
 4175        '''
 4176         Unique identifier of the Resource.
 4177        '''
 4178        self.name = name if name is not None else ''
 4179        '''
 4180         Unique human-readable name of the Resource.
 4181        '''
 4182        self.password = password if password is not None else ''
 4183        '''
 4184
 4185        '''
 4186        self.port = port if port is not None else 0
 4187        '''
 4188
 4189        '''
 4190        self.port_override = port_override if port_override is not None else 0
 4191        '''
 4192
 4193        '''
 4194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4195        '''
 4196         ID of the secret store containing credentials for this resource, if any.
 4197        '''
 4198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4199        '''
 4200         Tags is a map of key, value pairs.
 4201        '''
 4202        self.username = username if username is not None else ''
 4203        '''
 4204
 4205        '''
 4206
 4207    def __repr__(self):
 4208        return '<sdm.DB2LUW ' + \
 4209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4210            'database: ' + repr(self.database) + ' ' +\
 4211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4212            'healthy: ' + repr(self.healthy) + ' ' +\
 4213            'hostname: ' + repr(self.hostname) + ' ' +\
 4214            'id: ' + repr(self.id) + ' ' +\
 4215            'name: ' + repr(self.name) + ' ' +\
 4216            'password: ' + repr(self.password) + ' ' +\
 4217            'port: ' + repr(self.port) + ' ' +\
 4218            'port_override: ' + repr(self.port_override) + ' ' +\
 4219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4220            'tags: ' + repr(self.tags) + ' ' +\
 4221            'username: ' + repr(self.username) + ' ' +\
 4222            '>'
 4223
 4224    def to_dict(self):
 4225        return {
 4226            'bind_interface': self.bind_interface,
 4227            'database': self.database,
 4228            'egress_filter': self.egress_filter,
 4229            'healthy': self.healthy,
 4230            'hostname': self.hostname,
 4231            'id': self.id,
 4232            'name': self.name,
 4233            'password': self.password,
 4234            'port': self.port,
 4235            'port_override': self.port_override,
 4236            'secret_store_id': self.secret_store_id,
 4237            'tags': self.tags,
 4238            'username': self.username,
 4239        }
 4240
 4241    @classmethod
 4242    def from_dict(cls, d):
 4243        return cls(
 4244            bind_interface=d.get('bind_interface'),
 4245            database=d.get('database'),
 4246            egress_filter=d.get('egress_filter'),
 4247            healthy=d.get('healthy'),
 4248            hostname=d.get('hostname'),
 4249            id=d.get('id'),
 4250            name=d.get('name'),
 4251            password=d.get('password'),
 4252            port=d.get('port'),
 4253            port_override=d.get('port_override'),
 4254            secret_store_id=d.get('secret_store_id'),
 4255            tags=d.get('tags'),
 4256            username=d.get('username'),
 4257        )
 4258
 4259
 4260class DeleteResponseMetadata:
 4261    '''
 4262     DeleteResponseMetadata is reserved for future use.
 4263    '''
 4264    __slots__ = []
 4265
 4266    def __init__(self, ):
 4267        pass
 4268
 4269    def __repr__(self):
 4270        return '<sdm.DeleteResponseMetadata ' + \
 4271            '>'
 4272
 4273    def to_dict(self):
 4274        return {}
 4275
 4276    @classmethod
 4277    def from_dict(cls, d):
 4278        return cls()
 4279
 4280
 4281class DocumentDBHost:
 4282    '''
 4283
 4284    '''
 4285    __slots__ = [
 4286        'auth_database',
 4287        'bind_interface',
 4288        'egress_filter',
 4289        'healthy',
 4290        'hostname',
 4291        'id',
 4292        'name',
 4293        'password',
 4294        'port',
 4295        'port_override',
 4296        'secret_store_id',
 4297        'tags',
 4298        'username',
 4299    ]
 4300
 4301    def __init__(
 4302        self,
 4303        auth_database=None,
 4304        bind_interface=None,
 4305        egress_filter=None,
 4306        healthy=None,
 4307        hostname=None,
 4308        id=None,
 4309        name=None,
 4310        password=None,
 4311        port=None,
 4312        port_override=None,
 4313        secret_store_id=None,
 4314        tags=None,
 4315        username=None,
 4316    ):
 4317        self.auth_database = auth_database if auth_database is not None else ''
 4318        '''
 4319
 4320        '''
 4321        self.bind_interface = bind_interface if bind_interface is not None else ''
 4322        '''
 4323         Bind interface
 4324        '''
 4325        self.egress_filter = egress_filter if egress_filter is not None else ''
 4326        '''
 4327         A filter applied to the routing logic to pin datasource to nodes.
 4328        '''
 4329        self.healthy = healthy if healthy is not None else False
 4330        '''
 4331         True if the datasource is reachable and the credentials are valid.
 4332        '''
 4333        self.hostname = hostname if hostname is not None else ''
 4334        '''
 4335
 4336        '''
 4337        self.id = id if id is not None else ''
 4338        '''
 4339         Unique identifier of the Resource.
 4340        '''
 4341        self.name = name if name is not None else ''
 4342        '''
 4343         Unique human-readable name of the Resource.
 4344        '''
 4345        self.password = password if password is not None else ''
 4346        '''
 4347
 4348        '''
 4349        self.port = port if port is not None else 0
 4350        '''
 4351
 4352        '''
 4353        self.port_override = port_override if port_override is not None else 0
 4354        '''
 4355
 4356        '''
 4357        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4358        '''
 4359         ID of the secret store containing credentials for this resource, if any.
 4360        '''
 4361        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4362        '''
 4363         Tags is a map of key, value pairs.
 4364        '''
 4365        self.username = username if username is not None else ''
 4366        '''
 4367
 4368        '''
 4369
 4370    def __repr__(self):
 4371        return '<sdm.DocumentDBHost ' + \
 4372            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4373            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4374            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4375            'healthy: ' + repr(self.healthy) + ' ' +\
 4376            'hostname: ' + repr(self.hostname) + ' ' +\
 4377            'id: ' + repr(self.id) + ' ' +\
 4378            'name: ' + repr(self.name) + ' ' +\
 4379            'password: ' + repr(self.password) + ' ' +\
 4380            'port: ' + repr(self.port) + ' ' +\
 4381            'port_override: ' + repr(self.port_override) + ' ' +\
 4382            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4383            'tags: ' + repr(self.tags) + ' ' +\
 4384            'username: ' + repr(self.username) + ' ' +\
 4385            '>'
 4386
 4387    def to_dict(self):
 4388        return {
 4389            'auth_database': self.auth_database,
 4390            'bind_interface': self.bind_interface,
 4391            'egress_filter': self.egress_filter,
 4392            'healthy': self.healthy,
 4393            'hostname': self.hostname,
 4394            'id': self.id,
 4395            'name': self.name,
 4396            'password': self.password,
 4397            'port': self.port,
 4398            'port_override': self.port_override,
 4399            'secret_store_id': self.secret_store_id,
 4400            'tags': self.tags,
 4401            'username': self.username,
 4402        }
 4403
 4404    @classmethod
 4405    def from_dict(cls, d):
 4406        return cls(
 4407            auth_database=d.get('auth_database'),
 4408            bind_interface=d.get('bind_interface'),
 4409            egress_filter=d.get('egress_filter'),
 4410            healthy=d.get('healthy'),
 4411            hostname=d.get('hostname'),
 4412            id=d.get('id'),
 4413            name=d.get('name'),
 4414            password=d.get('password'),
 4415            port=d.get('port'),
 4416            port_override=d.get('port_override'),
 4417            secret_store_id=d.get('secret_store_id'),
 4418            tags=d.get('tags'),
 4419            username=d.get('username'),
 4420        )
 4421
 4422
 4423class DocumentDBReplicaSet:
 4424    '''
 4425
 4426    '''
 4427    __slots__ = [
 4428        'auth_database',
 4429        'bind_interface',
 4430        'connect_to_replica',
 4431        'egress_filter',
 4432        'healthy',
 4433        'hostname',
 4434        'id',
 4435        'name',
 4436        'password',
 4437        'port_override',
 4438        'replica_set',
 4439        'secret_store_id',
 4440        'tags',
 4441        'username',
 4442    ]
 4443
 4444    def __init__(
 4445        self,
 4446        auth_database=None,
 4447        bind_interface=None,
 4448        connect_to_replica=None,
 4449        egress_filter=None,
 4450        healthy=None,
 4451        hostname=None,
 4452        id=None,
 4453        name=None,
 4454        password=None,
 4455        port_override=None,
 4456        replica_set=None,
 4457        secret_store_id=None,
 4458        tags=None,
 4459        username=None,
 4460    ):
 4461        self.auth_database = auth_database if auth_database is not None else ''
 4462        '''
 4463
 4464        '''
 4465        self.bind_interface = bind_interface if bind_interface is not None else ''
 4466        '''
 4467         Bind interface
 4468        '''
 4469        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4470        '''
 4471
 4472        '''
 4473        self.egress_filter = egress_filter if egress_filter is not None else ''
 4474        '''
 4475         A filter applied to the routing logic to pin datasource to nodes.
 4476        '''
 4477        self.healthy = healthy if healthy is not None else False
 4478        '''
 4479         True if the datasource is reachable and the credentials are valid.
 4480        '''
 4481        self.hostname = hostname if hostname is not None else ''
 4482        '''
 4483         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4484        '''
 4485        self.id = id if id is not None else ''
 4486        '''
 4487         Unique identifier of the Resource.
 4488        '''
 4489        self.name = name if name is not None else ''
 4490        '''
 4491         Unique human-readable name of the Resource.
 4492        '''
 4493        self.password = password if password is not None else ''
 4494        '''
 4495
 4496        '''
 4497        self.port_override = port_override if port_override is not None else 0
 4498        '''
 4499
 4500        '''
 4501        self.replica_set = replica_set if replica_set is not None else ''
 4502        '''
 4503
 4504        '''
 4505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4506        '''
 4507         ID of the secret store containing credentials for this resource, if any.
 4508        '''
 4509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4510        '''
 4511         Tags is a map of key, value pairs.
 4512        '''
 4513        self.username = username if username is not None else ''
 4514        '''
 4515
 4516        '''
 4517
 4518    def __repr__(self):
 4519        return '<sdm.DocumentDBReplicaSet ' + \
 4520            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4521            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4522            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4523            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4524            'healthy: ' + repr(self.healthy) + ' ' +\
 4525            'hostname: ' + repr(self.hostname) + ' ' +\
 4526            'id: ' + repr(self.id) + ' ' +\
 4527            'name: ' + repr(self.name) + ' ' +\
 4528            'password: ' + repr(self.password) + ' ' +\
 4529            'port_override: ' + repr(self.port_override) + ' ' +\
 4530            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4531            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4532            'tags: ' + repr(self.tags) + ' ' +\
 4533            'username: ' + repr(self.username) + ' ' +\
 4534            '>'
 4535
 4536    def to_dict(self):
 4537        return {
 4538            'auth_database': self.auth_database,
 4539            'bind_interface': self.bind_interface,
 4540            'connect_to_replica': self.connect_to_replica,
 4541            'egress_filter': self.egress_filter,
 4542            'healthy': self.healthy,
 4543            'hostname': self.hostname,
 4544            'id': self.id,
 4545            'name': self.name,
 4546            'password': self.password,
 4547            'port_override': self.port_override,
 4548            'replica_set': self.replica_set,
 4549            'secret_store_id': self.secret_store_id,
 4550            'tags': self.tags,
 4551            'username': self.username,
 4552        }
 4553
 4554    @classmethod
 4555    def from_dict(cls, d):
 4556        return cls(
 4557            auth_database=d.get('auth_database'),
 4558            bind_interface=d.get('bind_interface'),
 4559            connect_to_replica=d.get('connect_to_replica'),
 4560            egress_filter=d.get('egress_filter'),
 4561            healthy=d.get('healthy'),
 4562            hostname=d.get('hostname'),
 4563            id=d.get('id'),
 4564            name=d.get('name'),
 4565            password=d.get('password'),
 4566            port_override=d.get('port_override'),
 4567            replica_set=d.get('replica_set'),
 4568            secret_store_id=d.get('secret_store_id'),
 4569            tags=d.get('tags'),
 4570            username=d.get('username'),
 4571        )
 4572
 4573
 4574class Druid:
 4575    '''
 4576
 4577    '''
 4578    __slots__ = [
 4579        'bind_interface',
 4580        'egress_filter',
 4581        'healthy',
 4582        'hostname',
 4583        'id',
 4584        'name',
 4585        'password',
 4586        'port',
 4587        'port_override',
 4588        'secret_store_id',
 4589        'tags',
 4590        'username',
 4591    ]
 4592
 4593    def __init__(
 4594        self,
 4595        bind_interface=None,
 4596        egress_filter=None,
 4597        healthy=None,
 4598        hostname=None,
 4599        id=None,
 4600        name=None,
 4601        password=None,
 4602        port=None,
 4603        port_override=None,
 4604        secret_store_id=None,
 4605        tags=None,
 4606        username=None,
 4607    ):
 4608        self.bind_interface = bind_interface if bind_interface is not None else ''
 4609        '''
 4610         Bind interface
 4611        '''
 4612        self.egress_filter = egress_filter if egress_filter is not None else ''
 4613        '''
 4614         A filter applied to the routing logic to pin datasource to nodes.
 4615        '''
 4616        self.healthy = healthy if healthy is not None else False
 4617        '''
 4618         True if the datasource is reachable and the credentials are valid.
 4619        '''
 4620        self.hostname = hostname if hostname is not None else ''
 4621        '''
 4622
 4623        '''
 4624        self.id = id if id is not None else ''
 4625        '''
 4626         Unique identifier of the Resource.
 4627        '''
 4628        self.name = name if name is not None else ''
 4629        '''
 4630         Unique human-readable name of the Resource.
 4631        '''
 4632        self.password = password if password is not None else ''
 4633        '''
 4634
 4635        '''
 4636        self.port = port if port is not None else 0
 4637        '''
 4638
 4639        '''
 4640        self.port_override = port_override if port_override is not None else 0
 4641        '''
 4642
 4643        '''
 4644        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4645        '''
 4646         ID of the secret store containing credentials for this resource, if any.
 4647        '''
 4648        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4649        '''
 4650         Tags is a map of key, value pairs.
 4651        '''
 4652        self.username = username if username is not None else ''
 4653        '''
 4654
 4655        '''
 4656
 4657    def __repr__(self):
 4658        return '<sdm.Druid ' + \
 4659            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4660            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4661            'healthy: ' + repr(self.healthy) + ' ' +\
 4662            'hostname: ' + repr(self.hostname) + ' ' +\
 4663            'id: ' + repr(self.id) + ' ' +\
 4664            'name: ' + repr(self.name) + ' ' +\
 4665            'password: ' + repr(self.password) + ' ' +\
 4666            'port: ' + repr(self.port) + ' ' +\
 4667            'port_override: ' + repr(self.port_override) + ' ' +\
 4668            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4669            'tags: ' + repr(self.tags) + ' ' +\
 4670            'username: ' + repr(self.username) + ' ' +\
 4671            '>'
 4672
 4673    def to_dict(self):
 4674        return {
 4675            'bind_interface': self.bind_interface,
 4676            'egress_filter': self.egress_filter,
 4677            'healthy': self.healthy,
 4678            'hostname': self.hostname,
 4679            'id': self.id,
 4680            'name': self.name,
 4681            'password': self.password,
 4682            'port': self.port,
 4683            'port_override': self.port_override,
 4684            'secret_store_id': self.secret_store_id,
 4685            'tags': self.tags,
 4686            'username': self.username,
 4687        }
 4688
 4689    @classmethod
 4690    def from_dict(cls, d):
 4691        return cls(
 4692            bind_interface=d.get('bind_interface'),
 4693            egress_filter=d.get('egress_filter'),
 4694            healthy=d.get('healthy'),
 4695            hostname=d.get('hostname'),
 4696            id=d.get('id'),
 4697            name=d.get('name'),
 4698            password=d.get('password'),
 4699            port=d.get('port'),
 4700            port_override=d.get('port_override'),
 4701            secret_store_id=d.get('secret_store_id'),
 4702            tags=d.get('tags'),
 4703            username=d.get('username'),
 4704        )
 4705
 4706
 4707class DynamoDB:
 4708    '''
 4709
 4710    '''
 4711    __slots__ = [
 4712        'access_key',
 4713        'bind_interface',
 4714        'egress_filter',
 4715        'endpoint',
 4716        'healthy',
 4717        'id',
 4718        'name',
 4719        'port_override',
 4720        'region',
 4721        'role_arn',
 4722        'role_external_id',
 4723        'secret_access_key',
 4724        'secret_store_id',
 4725        'tags',
 4726    ]
 4727
 4728    def __init__(
 4729        self,
 4730        access_key=None,
 4731        bind_interface=None,
 4732        egress_filter=None,
 4733        endpoint=None,
 4734        healthy=None,
 4735        id=None,
 4736        name=None,
 4737        port_override=None,
 4738        region=None,
 4739        role_arn=None,
 4740        role_external_id=None,
 4741        secret_access_key=None,
 4742        secret_store_id=None,
 4743        tags=None,
 4744    ):
 4745        self.access_key = access_key if access_key is not None else ''
 4746        '''
 4747
 4748        '''
 4749        self.bind_interface = bind_interface if bind_interface is not None else ''
 4750        '''
 4751         Bind interface
 4752        '''
 4753        self.egress_filter = egress_filter if egress_filter is not None else ''
 4754        '''
 4755         A filter applied to the routing logic to pin datasource to nodes.
 4756        '''
 4757        self.endpoint = endpoint if endpoint is not None else ''
 4758        '''
 4759
 4760        '''
 4761        self.healthy = healthy if healthy is not None else False
 4762        '''
 4763         True if the datasource is reachable and the credentials are valid.
 4764        '''
 4765        self.id = id if id is not None else ''
 4766        '''
 4767         Unique identifier of the Resource.
 4768        '''
 4769        self.name = name if name is not None else ''
 4770        '''
 4771         Unique human-readable name of the Resource.
 4772        '''
 4773        self.port_override = port_override if port_override is not None else 0
 4774        '''
 4775
 4776        '''
 4777        self.region = region if region is not None else ''
 4778        '''
 4779
 4780        '''
 4781        self.role_arn = role_arn if role_arn is not None else ''
 4782        '''
 4783
 4784        '''
 4785        self.role_external_id = role_external_id if role_external_id is not None else ''
 4786        '''
 4787
 4788        '''
 4789        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4790        '''
 4791
 4792        '''
 4793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4794        '''
 4795         ID of the secret store containing credentials for this resource, if any.
 4796        '''
 4797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4798        '''
 4799         Tags is a map of key, value pairs.
 4800        '''
 4801
 4802    def __repr__(self):
 4803        return '<sdm.DynamoDB ' + \
 4804            'access_key: ' + repr(self.access_key) + ' ' +\
 4805            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4807            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4808            'healthy: ' + repr(self.healthy) + ' ' +\
 4809            'id: ' + repr(self.id) + ' ' +\
 4810            'name: ' + repr(self.name) + ' ' +\
 4811            'port_override: ' + repr(self.port_override) + ' ' +\
 4812            'region: ' + repr(self.region) + ' ' +\
 4813            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4814            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4815            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4817            'tags: ' + repr(self.tags) + ' ' +\
 4818            '>'
 4819
 4820    def to_dict(self):
 4821        return {
 4822            'access_key': self.access_key,
 4823            'bind_interface': self.bind_interface,
 4824            'egress_filter': self.egress_filter,
 4825            'endpoint': self.endpoint,
 4826            'healthy': self.healthy,
 4827            'id': self.id,
 4828            'name': self.name,
 4829            'port_override': self.port_override,
 4830            'region': self.region,
 4831            'role_arn': self.role_arn,
 4832            'role_external_id': self.role_external_id,
 4833            'secret_access_key': self.secret_access_key,
 4834            'secret_store_id': self.secret_store_id,
 4835            'tags': self.tags,
 4836        }
 4837
 4838    @classmethod
 4839    def from_dict(cls, d):
 4840        return cls(
 4841            access_key=d.get('access_key'),
 4842            bind_interface=d.get('bind_interface'),
 4843            egress_filter=d.get('egress_filter'),
 4844            endpoint=d.get('endpoint'),
 4845            healthy=d.get('healthy'),
 4846            id=d.get('id'),
 4847            name=d.get('name'),
 4848            port_override=d.get('port_override'),
 4849            region=d.get('region'),
 4850            role_arn=d.get('role_arn'),
 4851            role_external_id=d.get('role_external_id'),
 4852            secret_access_key=d.get('secret_access_key'),
 4853            secret_store_id=d.get('secret_store_id'),
 4854            tags=d.get('tags'),
 4855        )
 4856
 4857
 4858class Elastic:
 4859    '''
 4860
 4861    '''
 4862    __slots__ = [
 4863        'bind_interface',
 4864        'egress_filter',
 4865        'healthy',
 4866        'hostname',
 4867        'id',
 4868        'name',
 4869        'password',
 4870        'port',
 4871        'port_override',
 4872        'secret_store_id',
 4873        'tags',
 4874        'tls_required',
 4875        'username',
 4876    ]
 4877
 4878    def __init__(
 4879        self,
 4880        bind_interface=None,
 4881        egress_filter=None,
 4882        healthy=None,
 4883        hostname=None,
 4884        id=None,
 4885        name=None,
 4886        password=None,
 4887        port=None,
 4888        port_override=None,
 4889        secret_store_id=None,
 4890        tags=None,
 4891        tls_required=None,
 4892        username=None,
 4893    ):
 4894        self.bind_interface = bind_interface if bind_interface is not None else ''
 4895        '''
 4896         Bind interface
 4897        '''
 4898        self.egress_filter = egress_filter if egress_filter is not None else ''
 4899        '''
 4900         A filter applied to the routing logic to pin datasource to nodes.
 4901        '''
 4902        self.healthy = healthy if healthy is not None else False
 4903        '''
 4904         True if the datasource is reachable and the credentials are valid.
 4905        '''
 4906        self.hostname = hostname if hostname is not None else ''
 4907        '''
 4908
 4909        '''
 4910        self.id = id if id is not None else ''
 4911        '''
 4912         Unique identifier of the Resource.
 4913        '''
 4914        self.name = name if name is not None else ''
 4915        '''
 4916         Unique human-readable name of the Resource.
 4917        '''
 4918        self.password = password if password is not None else ''
 4919        '''
 4920
 4921        '''
 4922        self.port = port if port is not None else 0
 4923        '''
 4924
 4925        '''
 4926        self.port_override = port_override if port_override is not None else 0
 4927        '''
 4928
 4929        '''
 4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4931        '''
 4932         ID of the secret store containing credentials for this resource, if any.
 4933        '''
 4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4935        '''
 4936         Tags is a map of key, value pairs.
 4937        '''
 4938        self.tls_required = tls_required if tls_required is not None else False
 4939        '''
 4940
 4941        '''
 4942        self.username = username if username is not None else ''
 4943        '''
 4944
 4945        '''
 4946
 4947    def __repr__(self):
 4948        return '<sdm.Elastic ' + \
 4949            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4950            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4951            'healthy: ' + repr(self.healthy) + ' ' +\
 4952            'hostname: ' + repr(self.hostname) + ' ' +\
 4953            'id: ' + repr(self.id) + ' ' +\
 4954            'name: ' + repr(self.name) + ' ' +\
 4955            'password: ' + repr(self.password) + ' ' +\
 4956            'port: ' + repr(self.port) + ' ' +\
 4957            'port_override: ' + repr(self.port_override) + ' ' +\
 4958            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4959            'tags: ' + repr(self.tags) + ' ' +\
 4960            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4961            'username: ' + repr(self.username) + ' ' +\
 4962            '>'
 4963
 4964    def to_dict(self):
 4965        return {
 4966            'bind_interface': self.bind_interface,
 4967            'egress_filter': self.egress_filter,
 4968            'healthy': self.healthy,
 4969            'hostname': self.hostname,
 4970            'id': self.id,
 4971            'name': self.name,
 4972            'password': self.password,
 4973            'port': self.port,
 4974            'port_override': self.port_override,
 4975            'secret_store_id': self.secret_store_id,
 4976            'tags': self.tags,
 4977            'tls_required': self.tls_required,
 4978            'username': self.username,
 4979        }
 4980
 4981    @classmethod
 4982    def from_dict(cls, d):
 4983        return cls(
 4984            bind_interface=d.get('bind_interface'),
 4985            egress_filter=d.get('egress_filter'),
 4986            healthy=d.get('healthy'),
 4987            hostname=d.get('hostname'),
 4988            id=d.get('id'),
 4989            name=d.get('name'),
 4990            password=d.get('password'),
 4991            port=d.get('port'),
 4992            port_override=d.get('port_override'),
 4993            secret_store_id=d.get('secret_store_id'),
 4994            tags=d.get('tags'),
 4995            tls_required=d.get('tls_required'),
 4996            username=d.get('username'),
 4997        )
 4998
 4999
 5000class ElasticacheRedis:
 5001    '''
 5002
 5003    '''
 5004    __slots__ = [
 5005        'bind_interface',
 5006        'egress_filter',
 5007        'healthy',
 5008        'hostname',
 5009        'id',
 5010        'name',
 5011        'password',
 5012        'port',
 5013        'port_override',
 5014        'secret_store_id',
 5015        'tags',
 5016        'tls_required',
 5017    ]
 5018
 5019    def __init__(
 5020        self,
 5021        bind_interface=None,
 5022        egress_filter=None,
 5023        healthy=None,
 5024        hostname=None,
 5025        id=None,
 5026        name=None,
 5027        password=None,
 5028        port=None,
 5029        port_override=None,
 5030        secret_store_id=None,
 5031        tags=None,
 5032        tls_required=None,
 5033    ):
 5034        self.bind_interface = bind_interface if bind_interface is not None else ''
 5035        '''
 5036         Bind interface
 5037        '''
 5038        self.egress_filter = egress_filter if egress_filter is not None else ''
 5039        '''
 5040         A filter applied to the routing logic to pin datasource to nodes.
 5041        '''
 5042        self.healthy = healthy if healthy is not None else False
 5043        '''
 5044         True if the datasource is reachable and the credentials are valid.
 5045        '''
 5046        self.hostname = hostname if hostname is not None else ''
 5047        '''
 5048
 5049        '''
 5050        self.id = id if id is not None else ''
 5051        '''
 5052         Unique identifier of the Resource.
 5053        '''
 5054        self.name = name if name is not None else ''
 5055        '''
 5056         Unique human-readable name of the Resource.
 5057        '''
 5058        self.password = password if password is not None else ''
 5059        '''
 5060
 5061        '''
 5062        self.port = port if port is not None else 0
 5063        '''
 5064
 5065        '''
 5066        self.port_override = port_override if port_override is not None else 0
 5067        '''
 5068
 5069        '''
 5070        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5071        '''
 5072         ID of the secret store containing credentials for this resource, if any.
 5073        '''
 5074        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5075        '''
 5076         Tags is a map of key, value pairs.
 5077        '''
 5078        self.tls_required = tls_required if tls_required is not None else False
 5079        '''
 5080
 5081        '''
 5082
 5083    def __repr__(self):
 5084        return '<sdm.ElasticacheRedis ' + \
 5085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5087            'healthy: ' + repr(self.healthy) + ' ' +\
 5088            'hostname: ' + repr(self.hostname) + ' ' +\
 5089            'id: ' + repr(self.id) + ' ' +\
 5090            'name: ' + repr(self.name) + ' ' +\
 5091            'password: ' + repr(self.password) + ' ' +\
 5092            'port: ' + repr(self.port) + ' ' +\
 5093            'port_override: ' + repr(self.port_override) + ' ' +\
 5094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5095            'tags: ' + repr(self.tags) + ' ' +\
 5096            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5097            '>'
 5098
 5099    def to_dict(self):
 5100        return {
 5101            'bind_interface': self.bind_interface,
 5102            'egress_filter': self.egress_filter,
 5103            'healthy': self.healthy,
 5104            'hostname': self.hostname,
 5105            'id': self.id,
 5106            'name': self.name,
 5107            'password': self.password,
 5108            'port': self.port,
 5109            'port_override': self.port_override,
 5110            'secret_store_id': self.secret_store_id,
 5111            'tags': self.tags,
 5112            'tls_required': self.tls_required,
 5113        }
 5114
 5115    @classmethod
 5116    def from_dict(cls, d):
 5117        return cls(
 5118            bind_interface=d.get('bind_interface'),
 5119            egress_filter=d.get('egress_filter'),
 5120            healthy=d.get('healthy'),
 5121            hostname=d.get('hostname'),
 5122            id=d.get('id'),
 5123            name=d.get('name'),
 5124            password=d.get('password'),
 5125            port=d.get('port'),
 5126            port_override=d.get('port_override'),
 5127            secret_store_id=d.get('secret_store_id'),
 5128            tags=d.get('tags'),
 5129            tls_required=d.get('tls_required'),
 5130        )
 5131
 5132
 5133class GCP:
 5134    '''
 5135
 5136    '''
 5137    __slots__ = [
 5138        'bind_interface',
 5139        'egress_filter',
 5140        'healthy',
 5141        'id',
 5142        'keyfile',
 5143        'name',
 5144        'scopes',
 5145        'secret_store_id',
 5146        'tags',
 5147    ]
 5148
 5149    def __init__(
 5150        self,
 5151        bind_interface=None,
 5152        egress_filter=None,
 5153        healthy=None,
 5154        id=None,
 5155        keyfile=None,
 5156        name=None,
 5157        scopes=None,
 5158        secret_store_id=None,
 5159        tags=None,
 5160    ):
 5161        self.bind_interface = bind_interface if bind_interface is not None else ''
 5162        '''
 5163         Bind interface
 5164        '''
 5165        self.egress_filter = egress_filter if egress_filter is not None else ''
 5166        '''
 5167         A filter applied to the routing logic to pin datasource to nodes.
 5168        '''
 5169        self.healthy = healthy if healthy is not None else False
 5170        '''
 5171         True if the datasource is reachable and the credentials are valid.
 5172        '''
 5173        self.id = id if id is not None else ''
 5174        '''
 5175         Unique identifier of the Resource.
 5176        '''
 5177        self.keyfile = keyfile if keyfile is not None else ''
 5178        '''
 5179
 5180        '''
 5181        self.name = name if name is not None else ''
 5182        '''
 5183         Unique human-readable name of the Resource.
 5184        '''
 5185        self.scopes = scopes if scopes is not None else ''
 5186        '''
 5187
 5188        '''
 5189        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5190        '''
 5191         ID of the secret store containing credentials for this resource, if any.
 5192        '''
 5193        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5194        '''
 5195         Tags is a map of key, value pairs.
 5196        '''
 5197
 5198    def __repr__(self):
 5199        return '<sdm.GCP ' + \
 5200            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5201            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5202            'healthy: ' + repr(self.healthy) + ' ' +\
 5203            'id: ' + repr(self.id) + ' ' +\
 5204            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5205            'name: ' + repr(self.name) + ' ' +\
 5206            'scopes: ' + repr(self.scopes) + ' ' +\
 5207            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5208            'tags: ' + repr(self.tags) + ' ' +\
 5209            '>'
 5210
 5211    def to_dict(self):
 5212        return {
 5213            'bind_interface': self.bind_interface,
 5214            'egress_filter': self.egress_filter,
 5215            'healthy': self.healthy,
 5216            'id': self.id,
 5217            'keyfile': self.keyfile,
 5218            'name': self.name,
 5219            'scopes': self.scopes,
 5220            'secret_store_id': self.secret_store_id,
 5221            'tags': self.tags,
 5222        }
 5223
 5224    @classmethod
 5225    def from_dict(cls, d):
 5226        return cls(
 5227            bind_interface=d.get('bind_interface'),
 5228            egress_filter=d.get('egress_filter'),
 5229            healthy=d.get('healthy'),
 5230            id=d.get('id'),
 5231            keyfile=d.get('keyfile'),
 5232            name=d.get('name'),
 5233            scopes=d.get('scopes'),
 5234            secret_store_id=d.get('secret_store_id'),
 5235            tags=d.get('tags'),
 5236        )
 5237
 5238
 5239class GCPStore:
 5240    '''
 5241
 5242    '''
 5243    __slots__ = [
 5244        'id',
 5245        'name',
 5246        'projectid',
 5247        'tags',
 5248    ]
 5249
 5250    def __init__(
 5251        self,
 5252        id=None,
 5253        name=None,
 5254        projectid=None,
 5255        tags=None,
 5256    ):
 5257        self.id = id if id is not None else ''
 5258        '''
 5259         Unique identifier of the SecretStore.
 5260        '''
 5261        self.name = name if name is not None else ''
 5262        '''
 5263         Unique human-readable name of the SecretStore.
 5264        '''
 5265        self.projectid = projectid if projectid is not None else ''
 5266        '''
 5267
 5268        '''
 5269        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5270        '''
 5271         Tags is a map of key, value pairs.
 5272        '''
 5273
 5274    def __repr__(self):
 5275        return '<sdm.GCPStore ' + \
 5276            'id: ' + repr(self.id) + ' ' +\
 5277            'name: ' + repr(self.name) + ' ' +\
 5278            'projectid: ' + repr(self.projectid) + ' ' +\
 5279            'tags: ' + repr(self.tags) + ' ' +\
 5280            '>'
 5281
 5282    def to_dict(self):
 5283        return {
 5284            'id': self.id,
 5285            'name': self.name,
 5286            'projectid': self.projectid,
 5287            'tags': self.tags,
 5288        }
 5289
 5290    @classmethod
 5291    def from_dict(cls, d):
 5292        return cls(
 5293            id=d.get('id'),
 5294            name=d.get('name'),
 5295            projectid=d.get('projectid'),
 5296            tags=d.get('tags'),
 5297        )
 5298
 5299
 5300class Gateway:
 5301    '''
 5302     Gateway represents a StrongDM CLI installation running in gateway mode.
 5303    '''
 5304    __slots__ = [
 5305        'bind_address',
 5306        'gateway_filter',
 5307        'id',
 5308        'listen_address',
 5309        'name',
 5310        'state',
 5311        'tags',
 5312    ]
 5313
 5314    def __init__(
 5315        self,
 5316        bind_address=None,
 5317        gateway_filter=None,
 5318        id=None,
 5319        listen_address=None,
 5320        name=None,
 5321        state=None,
 5322        tags=None,
 5323    ):
 5324        self.bind_address = bind_address if bind_address is not None else ''
 5325        '''
 5326         The hostname/port tuple which the gateway daemon will bind to.
 5327         If not provided on create, set to "0.0.0.0:listen_address_port".
 5328        '''
 5329        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5330        '''
 5331         GatewayFilter can be used to restrict the peering between relays and
 5332         gateways.
 5333        '''
 5334        self.id = id if id is not None else ''
 5335        '''
 5336         Unique identifier of the Gateway.
 5337        '''
 5338        self.listen_address = listen_address if listen_address is not None else ''
 5339        '''
 5340         The public hostname/port tuple at which the gateway will be accessible to clients.
 5341        '''
 5342        self.name = name if name is not None else ''
 5343        '''
 5344         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5345        '''
 5346        self.state = state if state is not None else ''
 5347        '''
 5348         The current state of the gateway. One of: "new", "verifying_restart",
 5349         "restarting", "started", "stopped", "dead", "unknown"
 5350        '''
 5351        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5352        '''
 5353         Tags is a map of key, value pairs.
 5354        '''
 5355
 5356    def __repr__(self):
 5357        return '<sdm.Gateway ' + \
 5358            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5359            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5360            'id: ' + repr(self.id) + ' ' +\
 5361            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5362            'name: ' + repr(self.name) + ' ' +\
 5363            'state: ' + repr(self.state) + ' ' +\
 5364            'tags: ' + repr(self.tags) + ' ' +\
 5365            '>'
 5366
 5367    def to_dict(self):
 5368        return {
 5369            'bind_address': self.bind_address,
 5370            'gateway_filter': self.gateway_filter,
 5371            'id': self.id,
 5372            'listen_address': self.listen_address,
 5373            'name': self.name,
 5374            'state': self.state,
 5375            'tags': self.tags,
 5376        }
 5377
 5378    @classmethod
 5379    def from_dict(cls, d):
 5380        return cls(
 5381            bind_address=d.get('bind_address'),
 5382            gateway_filter=d.get('gateway_filter'),
 5383            id=d.get('id'),
 5384            listen_address=d.get('listen_address'),
 5385            name=d.get('name'),
 5386            state=d.get('state'),
 5387            tags=d.get('tags'),
 5388        )
 5389
 5390
 5391class GetResponseMetadata:
 5392    '''
 5393     GetResponseMetadata is reserved for future use.
 5394    '''
 5395    __slots__ = []
 5396
 5397    def __init__(self, ):
 5398        pass
 5399
 5400    def __repr__(self):
 5401        return '<sdm.GetResponseMetadata ' + \
 5402            '>'
 5403
 5404    def to_dict(self):
 5405        return {}
 5406
 5407    @classmethod
 5408    def from_dict(cls, d):
 5409        return cls()
 5410
 5411
 5412class GoogleGKE:
 5413    '''
 5414
 5415    '''
 5416    __slots__ = [
 5417        'bind_interface',
 5418        'certificate_authority',
 5419        'egress_filter',
 5420        'endpoint',
 5421        'healthcheck_namespace',
 5422        'healthy',
 5423        'id',
 5424        'name',
 5425        'remote_identity_group_id',
 5426        'remote_identity_healthcheck_username',
 5427        'secret_store_id',
 5428        'service_account_key',
 5429        'tags',
 5430    ]
 5431
 5432    def __init__(
 5433        self,
 5434        bind_interface=None,
 5435        certificate_authority=None,
 5436        egress_filter=None,
 5437        endpoint=None,
 5438        healthcheck_namespace=None,
 5439        healthy=None,
 5440        id=None,
 5441        name=None,
 5442        remote_identity_group_id=None,
 5443        remote_identity_healthcheck_username=None,
 5444        secret_store_id=None,
 5445        service_account_key=None,
 5446        tags=None,
 5447    ):
 5448        self.bind_interface = bind_interface if bind_interface is not None else ''
 5449        '''
 5450         Bind interface
 5451        '''
 5452        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5453        '''
 5454
 5455        '''
 5456        self.egress_filter = egress_filter if egress_filter is not None else ''
 5457        '''
 5458         A filter applied to the routing logic to pin datasource to nodes.
 5459        '''
 5460        self.endpoint = endpoint if endpoint is not None else ''
 5461        '''
 5462
 5463        '''
 5464        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5465        '''
 5466         The path used to check the health of your connection.  Defaults to `default`.
 5467        '''
 5468        self.healthy = healthy if healthy is not None else False
 5469        '''
 5470         True if the datasource is reachable and the credentials are valid.
 5471        '''
 5472        self.id = id if id is not None else ''
 5473        '''
 5474         Unique identifier of the Resource.
 5475        '''
 5476        self.name = name if name is not None else ''
 5477        '''
 5478         Unique human-readable name of the Resource.
 5479        '''
 5480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5481        '''
 5482
 5483        '''
 5484        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5485        '''
 5486
 5487        '''
 5488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5489        '''
 5490         ID of the secret store containing credentials for this resource, if any.
 5491        '''
 5492        self.service_account_key = service_account_key if service_account_key is not None else ''
 5493        '''
 5494
 5495        '''
 5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5497        '''
 5498         Tags is a map of key, value pairs.
 5499        '''
 5500
 5501    def __repr__(self):
 5502        return '<sdm.GoogleGKE ' + \
 5503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5504            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5506            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5507            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5508            'healthy: ' + repr(self.healthy) + ' ' +\
 5509            'id: ' + repr(self.id) + ' ' +\
 5510            'name: ' + repr(self.name) + ' ' +\
 5511            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5512            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5514            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5515            'tags: ' + repr(self.tags) + ' ' +\
 5516            '>'
 5517
 5518    def to_dict(self):
 5519        return {
 5520            'bind_interface': self.bind_interface,
 5521            'certificate_authority': self.certificate_authority,
 5522            'egress_filter': self.egress_filter,
 5523            'endpoint': self.endpoint,
 5524            'healthcheck_namespace': self.healthcheck_namespace,
 5525            'healthy': self.healthy,
 5526            'id': self.id,
 5527            'name': self.name,
 5528            'remote_identity_group_id': self.remote_identity_group_id,
 5529            'remote_identity_healthcheck_username':
 5530            self.remote_identity_healthcheck_username,
 5531            'secret_store_id': self.secret_store_id,
 5532            'service_account_key': self.service_account_key,
 5533            'tags': self.tags,
 5534        }
 5535
 5536    @classmethod
 5537    def from_dict(cls, d):
 5538        return cls(
 5539            bind_interface=d.get('bind_interface'),
 5540            certificate_authority=d.get('certificate_authority'),
 5541            egress_filter=d.get('egress_filter'),
 5542            endpoint=d.get('endpoint'),
 5543            healthcheck_namespace=d.get('healthcheck_namespace'),
 5544            healthy=d.get('healthy'),
 5545            id=d.get('id'),
 5546            name=d.get('name'),
 5547            remote_identity_group_id=d.get('remote_identity_group_id'),
 5548            remote_identity_healthcheck_username=d.get(
 5549                'remote_identity_healthcheck_username'),
 5550            secret_store_id=d.get('secret_store_id'),
 5551            service_account_key=d.get('service_account_key'),
 5552            tags=d.get('tags'),
 5553        )
 5554
 5555
 5556class GoogleGKEUserImpersonation:
 5557    '''
 5558
 5559    '''
 5560    __slots__ = [
 5561        'bind_interface',
 5562        'certificate_authority',
 5563        'egress_filter',
 5564        'endpoint',
 5565        'healthcheck_namespace',
 5566        'healthy',
 5567        'id',
 5568        'name',
 5569        'secret_store_id',
 5570        'service_account_key',
 5571        'tags',
 5572    ]
 5573
 5574    def __init__(
 5575        self,
 5576        bind_interface=None,
 5577        certificate_authority=None,
 5578        egress_filter=None,
 5579        endpoint=None,
 5580        healthcheck_namespace=None,
 5581        healthy=None,
 5582        id=None,
 5583        name=None,
 5584        secret_store_id=None,
 5585        service_account_key=None,
 5586        tags=None,
 5587    ):
 5588        self.bind_interface = bind_interface if bind_interface is not None else ''
 5589        '''
 5590         Bind interface
 5591        '''
 5592        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5593        '''
 5594
 5595        '''
 5596        self.egress_filter = egress_filter if egress_filter is not None else ''
 5597        '''
 5598         A filter applied to the routing logic to pin datasource to nodes.
 5599        '''
 5600        self.endpoint = endpoint if endpoint is not None else ''
 5601        '''
 5602
 5603        '''
 5604        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5605        '''
 5606         The path used to check the health of your connection.  Defaults to `default`.
 5607        '''
 5608        self.healthy = healthy if healthy is not None else False
 5609        '''
 5610         True if the datasource is reachable and the credentials are valid.
 5611        '''
 5612        self.id = id if id is not None else ''
 5613        '''
 5614         Unique identifier of the Resource.
 5615        '''
 5616        self.name = name if name is not None else ''
 5617        '''
 5618         Unique human-readable name of the Resource.
 5619        '''
 5620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5621        '''
 5622         ID of the secret store containing credentials for this resource, if any.
 5623        '''
 5624        self.service_account_key = service_account_key if service_account_key is not None else ''
 5625        '''
 5626
 5627        '''
 5628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5629        '''
 5630         Tags is a map of key, value pairs.
 5631        '''
 5632
 5633    def __repr__(self):
 5634        return '<sdm.GoogleGKEUserImpersonation ' + \
 5635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5636            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5638            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5639            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5640            'healthy: ' + repr(self.healthy) + ' ' +\
 5641            'id: ' + repr(self.id) + ' ' +\
 5642            'name: ' + repr(self.name) + ' ' +\
 5643            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5644            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5645            'tags: ' + repr(self.tags) + ' ' +\
 5646            '>'
 5647
 5648    def to_dict(self):
 5649        return {
 5650            'bind_interface': self.bind_interface,
 5651            'certificate_authority': self.certificate_authority,
 5652            'egress_filter': self.egress_filter,
 5653            'endpoint': self.endpoint,
 5654            'healthcheck_namespace': self.healthcheck_namespace,
 5655            'healthy': self.healthy,
 5656            'id': self.id,
 5657            'name': self.name,
 5658            'secret_store_id': self.secret_store_id,
 5659            'service_account_key': self.service_account_key,
 5660            'tags': self.tags,
 5661        }
 5662
 5663    @classmethod
 5664    def from_dict(cls, d):
 5665        return cls(
 5666            bind_interface=d.get('bind_interface'),
 5667            certificate_authority=d.get('certificate_authority'),
 5668            egress_filter=d.get('egress_filter'),
 5669            endpoint=d.get('endpoint'),
 5670            healthcheck_namespace=d.get('healthcheck_namespace'),
 5671            healthy=d.get('healthy'),
 5672            id=d.get('id'),
 5673            name=d.get('name'),
 5674            secret_store_id=d.get('secret_store_id'),
 5675            service_account_key=d.get('service_account_key'),
 5676            tags=d.get('tags'),
 5677        )
 5678
 5679
 5680class Greenplum:
 5681    '''
 5682
 5683    '''
 5684    __slots__ = [
 5685        'bind_interface',
 5686        'database',
 5687        'egress_filter',
 5688        'healthy',
 5689        'hostname',
 5690        'id',
 5691        'name',
 5692        'override_database',
 5693        'password',
 5694        'port',
 5695        'port_override',
 5696        'secret_store_id',
 5697        'tags',
 5698        'username',
 5699    ]
 5700
 5701    def __init__(
 5702        self,
 5703        bind_interface=None,
 5704        database=None,
 5705        egress_filter=None,
 5706        healthy=None,
 5707        hostname=None,
 5708        id=None,
 5709        name=None,
 5710        override_database=None,
 5711        password=None,
 5712        port=None,
 5713        port_override=None,
 5714        secret_store_id=None,
 5715        tags=None,
 5716        username=None,
 5717    ):
 5718        self.bind_interface = bind_interface if bind_interface is not None else ''
 5719        '''
 5720         Bind interface
 5721        '''
 5722        self.database = database if database is not None else ''
 5723        '''
 5724
 5725        '''
 5726        self.egress_filter = egress_filter if egress_filter is not None else ''
 5727        '''
 5728         A filter applied to the routing logic to pin datasource to nodes.
 5729        '''
 5730        self.healthy = healthy if healthy is not None else False
 5731        '''
 5732         True if the datasource is reachable and the credentials are valid.
 5733        '''
 5734        self.hostname = hostname if hostname is not None else ''
 5735        '''
 5736
 5737        '''
 5738        self.id = id if id is not None else ''
 5739        '''
 5740         Unique identifier of the Resource.
 5741        '''
 5742        self.name = name if name is not None else ''
 5743        '''
 5744         Unique human-readable name of the Resource.
 5745        '''
 5746        self.override_database = override_database if override_database is not None else False
 5747        '''
 5748
 5749        '''
 5750        self.password = password if password is not None else ''
 5751        '''
 5752
 5753        '''
 5754        self.port = port if port is not None else 0
 5755        '''
 5756
 5757        '''
 5758        self.port_override = port_override if port_override is not None else 0
 5759        '''
 5760
 5761        '''
 5762        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5763        '''
 5764         ID of the secret store containing credentials for this resource, if any.
 5765        '''
 5766        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5767        '''
 5768         Tags is a map of key, value pairs.
 5769        '''
 5770        self.username = username if username is not None else ''
 5771        '''
 5772
 5773        '''
 5774
 5775    def __repr__(self):
 5776        return '<sdm.Greenplum ' + \
 5777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5778            'database: ' + repr(self.database) + ' ' +\
 5779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5780            'healthy: ' + repr(self.healthy) + ' ' +\
 5781            'hostname: ' + repr(self.hostname) + ' ' +\
 5782            'id: ' + repr(self.id) + ' ' +\
 5783            'name: ' + repr(self.name) + ' ' +\
 5784            'override_database: ' + repr(self.override_database) + ' ' +\
 5785            'password: ' + repr(self.password) + ' ' +\
 5786            'port: ' + repr(self.port) + ' ' +\
 5787            'port_override: ' + repr(self.port_override) + ' ' +\
 5788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5789            'tags: ' + repr(self.tags) + ' ' +\
 5790            'username: ' + repr(self.username) + ' ' +\
 5791            '>'
 5792
 5793    def to_dict(self):
 5794        return {
 5795            'bind_interface': self.bind_interface,
 5796            'database': self.database,
 5797            'egress_filter': self.egress_filter,
 5798            'healthy': self.healthy,
 5799            'hostname': self.hostname,
 5800            'id': self.id,
 5801            'name': self.name,
 5802            'override_database': self.override_database,
 5803            'password': self.password,
 5804            'port': self.port,
 5805            'port_override': self.port_override,
 5806            'secret_store_id': self.secret_store_id,
 5807            'tags': self.tags,
 5808            'username': self.username,
 5809        }
 5810
 5811    @classmethod
 5812    def from_dict(cls, d):
 5813        return cls(
 5814            bind_interface=d.get('bind_interface'),
 5815            database=d.get('database'),
 5816            egress_filter=d.get('egress_filter'),
 5817            healthy=d.get('healthy'),
 5818            hostname=d.get('hostname'),
 5819            id=d.get('id'),
 5820            name=d.get('name'),
 5821            override_database=d.get('override_database'),
 5822            password=d.get('password'),
 5823            port=d.get('port'),
 5824            port_override=d.get('port_override'),
 5825            secret_store_id=d.get('secret_store_id'),
 5826            tags=d.get('tags'),
 5827            username=d.get('username'),
 5828        )
 5829
 5830
 5831class HTTPAuth:
 5832    '''
 5833
 5834    '''
 5835    __slots__ = [
 5836        'auth_header',
 5837        'bind_interface',
 5838        'default_path',
 5839        'egress_filter',
 5840        'headers_blacklist',
 5841        'healthcheck_path',
 5842        'healthy',
 5843        'id',
 5844        'name',
 5845        'secret_store_id',
 5846        'subdomain',
 5847        'tags',
 5848        'url',
 5849    ]
 5850
 5851    def __init__(
 5852        self,
 5853        auth_header=None,
 5854        bind_interface=None,
 5855        default_path=None,
 5856        egress_filter=None,
 5857        headers_blacklist=None,
 5858        healthcheck_path=None,
 5859        healthy=None,
 5860        id=None,
 5861        name=None,
 5862        secret_store_id=None,
 5863        subdomain=None,
 5864        tags=None,
 5865        url=None,
 5866    ):
 5867        self.auth_header = auth_header if auth_header is not None else ''
 5868        '''
 5869
 5870        '''
 5871        self.bind_interface = bind_interface if bind_interface is not None else ''
 5872        '''
 5873         Bind interface
 5874        '''
 5875        self.default_path = default_path if default_path is not None else ''
 5876        '''
 5877
 5878        '''
 5879        self.egress_filter = egress_filter if egress_filter is not None else ''
 5880        '''
 5881         A filter applied to the routing logic to pin datasource to nodes.
 5882        '''
 5883        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5884        '''
 5885
 5886        '''
 5887        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5888        '''
 5889
 5890        '''
 5891        self.healthy = healthy if healthy is not None else False
 5892        '''
 5893         True if the datasource is reachable and the credentials are valid.
 5894        '''
 5895        self.id = id if id is not None else ''
 5896        '''
 5897         Unique identifier of the Resource.
 5898        '''
 5899        self.name = name if name is not None else ''
 5900        '''
 5901         Unique human-readable name of the Resource.
 5902        '''
 5903        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5904        '''
 5905         ID of the secret store containing credentials for this resource, if any.
 5906        '''
 5907        self.subdomain = subdomain if subdomain is not None else ''
 5908        '''
 5909
 5910        '''
 5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5912        '''
 5913         Tags is a map of key, value pairs.
 5914        '''
 5915        self.url = url if url is not None else ''
 5916        '''
 5917
 5918        '''
 5919
 5920    def __repr__(self):
 5921        return '<sdm.HTTPAuth ' + \
 5922            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5924            'default_path: ' + repr(self.default_path) + ' ' +\
 5925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5926            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5927            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5928            'healthy: ' + repr(self.healthy) + ' ' +\
 5929            'id: ' + repr(self.id) + ' ' +\
 5930            'name: ' + repr(self.name) + ' ' +\
 5931            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5932            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5933            'tags: ' + repr(self.tags) + ' ' +\
 5934            'url: ' + repr(self.url) + ' ' +\
 5935            '>'
 5936
 5937    def to_dict(self):
 5938        return {
 5939            'auth_header': self.auth_header,
 5940            'bind_interface': self.bind_interface,
 5941            'default_path': self.default_path,
 5942            'egress_filter': self.egress_filter,
 5943            'headers_blacklist': self.headers_blacklist,
 5944            'healthcheck_path': self.healthcheck_path,
 5945            'healthy': self.healthy,
 5946            'id': self.id,
 5947            'name': self.name,
 5948            'secret_store_id': self.secret_store_id,
 5949            'subdomain': self.subdomain,
 5950            'tags': self.tags,
 5951            'url': self.url,
 5952        }
 5953
 5954    @classmethod
 5955    def from_dict(cls, d):
 5956        return cls(
 5957            auth_header=d.get('auth_header'),
 5958            bind_interface=d.get('bind_interface'),
 5959            default_path=d.get('default_path'),
 5960            egress_filter=d.get('egress_filter'),
 5961            headers_blacklist=d.get('headers_blacklist'),
 5962            healthcheck_path=d.get('healthcheck_path'),
 5963            healthy=d.get('healthy'),
 5964            id=d.get('id'),
 5965            name=d.get('name'),
 5966            secret_store_id=d.get('secret_store_id'),
 5967            subdomain=d.get('subdomain'),
 5968            tags=d.get('tags'),
 5969            url=d.get('url'),
 5970        )
 5971
 5972
 5973class HTTPBasicAuth:
 5974    '''
 5975
 5976    '''
 5977    __slots__ = [
 5978        'bind_interface',
 5979        'default_path',
 5980        'egress_filter',
 5981        'headers_blacklist',
 5982        'healthcheck_path',
 5983        'healthy',
 5984        'id',
 5985        'name',
 5986        'password',
 5987        'secret_store_id',
 5988        'subdomain',
 5989        'tags',
 5990        'url',
 5991        'username',
 5992    ]
 5993
 5994    def __init__(
 5995        self,
 5996        bind_interface=None,
 5997        default_path=None,
 5998        egress_filter=None,
 5999        headers_blacklist=None,
 6000        healthcheck_path=None,
 6001        healthy=None,
 6002        id=None,
 6003        name=None,
 6004        password=None,
 6005        secret_store_id=None,
 6006        subdomain=None,
 6007        tags=None,
 6008        url=None,
 6009        username=None,
 6010    ):
 6011        self.bind_interface = bind_interface if bind_interface is not None else ''
 6012        '''
 6013         Bind interface
 6014        '''
 6015        self.default_path = default_path if default_path is not None else ''
 6016        '''
 6017
 6018        '''
 6019        self.egress_filter = egress_filter if egress_filter is not None else ''
 6020        '''
 6021         A filter applied to the routing logic to pin datasource to nodes.
 6022        '''
 6023        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6024        '''
 6025
 6026        '''
 6027        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6028        '''
 6029
 6030        '''
 6031        self.healthy = healthy if healthy is not None else False
 6032        '''
 6033         True if the datasource is reachable and the credentials are valid.
 6034        '''
 6035        self.id = id if id is not None else ''
 6036        '''
 6037         Unique identifier of the Resource.
 6038        '''
 6039        self.name = name if name is not None else ''
 6040        '''
 6041         Unique human-readable name of the Resource.
 6042        '''
 6043        self.password = password if password is not None else ''
 6044        '''
 6045
 6046        '''
 6047        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6048        '''
 6049         ID of the secret store containing credentials for this resource, if any.
 6050        '''
 6051        self.subdomain = subdomain if subdomain is not None else ''
 6052        '''
 6053
 6054        '''
 6055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6056        '''
 6057         Tags is a map of key, value pairs.
 6058        '''
 6059        self.url = url if url is not None else ''
 6060        '''
 6061
 6062        '''
 6063        self.username = username if username is not None else ''
 6064        '''
 6065
 6066        '''
 6067
 6068    def __repr__(self):
 6069        return '<sdm.HTTPBasicAuth ' + \
 6070            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6071            'default_path: ' + repr(self.default_path) + ' ' +\
 6072            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6073            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6074            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6075            'healthy: ' + repr(self.healthy) + ' ' +\
 6076            'id: ' + repr(self.id) + ' ' +\
 6077            'name: ' + repr(self.name) + ' ' +\
 6078            'password: ' + repr(self.password) + ' ' +\
 6079            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6080            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6081            'tags: ' + repr(self.tags) + ' ' +\
 6082            'url: ' + repr(self.url) + ' ' +\
 6083            'username: ' + repr(self.username) + ' ' +\
 6084            '>'
 6085
 6086    def to_dict(self):
 6087        return {
 6088            'bind_interface': self.bind_interface,
 6089            'default_path': self.default_path,
 6090            'egress_filter': self.egress_filter,
 6091            'headers_blacklist': self.headers_blacklist,
 6092            'healthcheck_path': self.healthcheck_path,
 6093            'healthy': self.healthy,
 6094            'id': self.id,
 6095            'name': self.name,
 6096            'password': self.password,
 6097            'secret_store_id': self.secret_store_id,
 6098            'subdomain': self.subdomain,
 6099            'tags': self.tags,
 6100            'url': self.url,
 6101            'username': self.username,
 6102        }
 6103
 6104    @classmethod
 6105    def from_dict(cls, d):
 6106        return cls(
 6107            bind_interface=d.get('bind_interface'),
 6108            default_path=d.get('default_path'),
 6109            egress_filter=d.get('egress_filter'),
 6110            headers_blacklist=d.get('headers_blacklist'),
 6111            healthcheck_path=d.get('healthcheck_path'),
 6112            healthy=d.get('healthy'),
 6113            id=d.get('id'),
 6114            name=d.get('name'),
 6115            password=d.get('password'),
 6116            secret_store_id=d.get('secret_store_id'),
 6117            subdomain=d.get('subdomain'),
 6118            tags=d.get('tags'),
 6119            url=d.get('url'),
 6120            username=d.get('username'),
 6121        )
 6122
 6123
 6124class HTTPNoAuth:
 6125    '''
 6126
 6127    '''
 6128    __slots__ = [
 6129        'bind_interface',
 6130        'default_path',
 6131        'egress_filter',
 6132        'headers_blacklist',
 6133        'healthcheck_path',
 6134        'healthy',
 6135        'id',
 6136        'name',
 6137        'secret_store_id',
 6138        'subdomain',
 6139        'tags',
 6140        'url',
 6141    ]
 6142
 6143    def __init__(
 6144        self,
 6145        bind_interface=None,
 6146        default_path=None,
 6147        egress_filter=None,
 6148        headers_blacklist=None,
 6149        healthcheck_path=None,
 6150        healthy=None,
 6151        id=None,
 6152        name=None,
 6153        secret_store_id=None,
 6154        subdomain=None,
 6155        tags=None,
 6156        url=None,
 6157    ):
 6158        self.bind_interface = bind_interface if bind_interface is not None else ''
 6159        '''
 6160         Bind interface
 6161        '''
 6162        self.default_path = default_path if default_path is not None else ''
 6163        '''
 6164
 6165        '''
 6166        self.egress_filter = egress_filter if egress_filter is not None else ''
 6167        '''
 6168         A filter applied to the routing logic to pin datasource to nodes.
 6169        '''
 6170        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6171        '''
 6172
 6173        '''
 6174        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6175        '''
 6176
 6177        '''
 6178        self.healthy = healthy if healthy is not None else False
 6179        '''
 6180         True if the datasource is reachable and the credentials are valid.
 6181        '''
 6182        self.id = id if id is not None else ''
 6183        '''
 6184         Unique identifier of the Resource.
 6185        '''
 6186        self.name = name if name is not None else ''
 6187        '''
 6188         Unique human-readable name of the Resource.
 6189        '''
 6190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6191        '''
 6192         ID of the secret store containing credentials for this resource, if any.
 6193        '''
 6194        self.subdomain = subdomain if subdomain is not None else ''
 6195        '''
 6196
 6197        '''
 6198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6199        '''
 6200         Tags is a map of key, value pairs.
 6201        '''
 6202        self.url = url if url is not None else ''
 6203        '''
 6204
 6205        '''
 6206
 6207    def __repr__(self):
 6208        return '<sdm.HTTPNoAuth ' + \
 6209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6210            'default_path: ' + repr(self.default_path) + ' ' +\
 6211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6212            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6213            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6214            'healthy: ' + repr(self.healthy) + ' ' +\
 6215            'id: ' + repr(self.id) + ' ' +\
 6216            'name: ' + repr(self.name) + ' ' +\
 6217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6218            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6219            'tags: ' + repr(self.tags) + ' ' +\
 6220            'url: ' + repr(self.url) + ' ' +\
 6221            '>'
 6222
 6223    def to_dict(self):
 6224        return {
 6225            'bind_interface': self.bind_interface,
 6226            'default_path': self.default_path,
 6227            'egress_filter': self.egress_filter,
 6228            'headers_blacklist': self.headers_blacklist,
 6229            'healthcheck_path': self.healthcheck_path,
 6230            'healthy': self.healthy,
 6231            'id': self.id,
 6232            'name': self.name,
 6233            'secret_store_id': self.secret_store_id,
 6234            'subdomain': self.subdomain,
 6235            'tags': self.tags,
 6236            'url': self.url,
 6237        }
 6238
 6239    @classmethod
 6240    def from_dict(cls, d):
 6241        return cls(
 6242            bind_interface=d.get('bind_interface'),
 6243            default_path=d.get('default_path'),
 6244            egress_filter=d.get('egress_filter'),
 6245            headers_blacklist=d.get('headers_blacklist'),
 6246            healthcheck_path=d.get('healthcheck_path'),
 6247            healthy=d.get('healthy'),
 6248            id=d.get('id'),
 6249            name=d.get('name'),
 6250            secret_store_id=d.get('secret_store_id'),
 6251            subdomain=d.get('subdomain'),
 6252            tags=d.get('tags'),
 6253            url=d.get('url'),
 6254        )
 6255
 6256
 6257class Kubernetes:
 6258    '''
 6259
 6260    '''
 6261    __slots__ = [
 6262        'bind_interface',
 6263        'certificate_authority',
 6264        'client_certificate',
 6265        'client_key',
 6266        'egress_filter',
 6267        'healthcheck_namespace',
 6268        'healthy',
 6269        'hostname',
 6270        'id',
 6271        'name',
 6272        'port',
 6273        'port_override',
 6274        'remote_identity_group_id',
 6275        'remote_identity_healthcheck_username',
 6276        'secret_store_id',
 6277        'tags',
 6278    ]
 6279
 6280    def __init__(
 6281        self,
 6282        bind_interface=None,
 6283        certificate_authority=None,
 6284        client_certificate=None,
 6285        client_key=None,
 6286        egress_filter=None,
 6287        healthcheck_namespace=None,
 6288        healthy=None,
 6289        hostname=None,
 6290        id=None,
 6291        name=None,
 6292        port=None,
 6293        port_override=None,
 6294        remote_identity_group_id=None,
 6295        remote_identity_healthcheck_username=None,
 6296        secret_store_id=None,
 6297        tags=None,
 6298    ):
 6299        self.bind_interface = bind_interface if bind_interface is not None else ''
 6300        '''
 6301         Bind interface
 6302        '''
 6303        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6304        '''
 6305
 6306        '''
 6307        self.client_certificate = client_certificate if client_certificate is not None else ''
 6308        '''
 6309
 6310        '''
 6311        self.client_key = client_key if client_key is not None else ''
 6312        '''
 6313
 6314        '''
 6315        self.egress_filter = egress_filter if egress_filter is not None else ''
 6316        '''
 6317         A filter applied to the routing logic to pin datasource to nodes.
 6318        '''
 6319        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6320        '''
 6321         The path used to check the health of your connection.  Defaults to `default`.
 6322        '''
 6323        self.healthy = healthy if healthy is not None else False
 6324        '''
 6325         True if the datasource is reachable and the credentials are valid.
 6326        '''
 6327        self.hostname = hostname if hostname is not None else ''
 6328        '''
 6329
 6330        '''
 6331        self.id = id if id is not None else ''
 6332        '''
 6333         Unique identifier of the Resource.
 6334        '''
 6335        self.name = name if name is not None else ''
 6336        '''
 6337         Unique human-readable name of the Resource.
 6338        '''
 6339        self.port = port if port is not None else 0
 6340        '''
 6341
 6342        '''
 6343        self.port_override = port_override if port_override is not None else 0
 6344        '''
 6345
 6346        '''
 6347        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6348        '''
 6349
 6350        '''
 6351        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6352        '''
 6353
 6354        '''
 6355        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6356        '''
 6357         ID of the secret store containing credentials for this resource, if any.
 6358        '''
 6359        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6360        '''
 6361         Tags is a map of key, value pairs.
 6362        '''
 6363
 6364    def __repr__(self):
 6365        return '<sdm.Kubernetes ' + \
 6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6367            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6368            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6369            'client_key: ' + repr(self.client_key) + ' ' +\
 6370            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6371            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6372            'healthy: ' + repr(self.healthy) + ' ' +\
 6373            'hostname: ' + repr(self.hostname) + ' ' +\
 6374            'id: ' + repr(self.id) + ' ' +\
 6375            'name: ' + repr(self.name) + ' ' +\
 6376            'port: ' + repr(self.port) + ' ' +\
 6377            'port_override: ' + repr(self.port_override) + ' ' +\
 6378            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6379            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6380            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6381            'tags: ' + repr(self.tags) + ' ' +\
 6382            '>'
 6383
 6384    def to_dict(self):
 6385        return {
 6386            'bind_interface': self.bind_interface,
 6387            'certificate_authority': self.certificate_authority,
 6388            'client_certificate': self.client_certificate,
 6389            'client_key': self.client_key,
 6390            'egress_filter': self.egress_filter,
 6391            'healthcheck_namespace': self.healthcheck_namespace,
 6392            'healthy': self.healthy,
 6393            'hostname': self.hostname,
 6394            'id': self.id,
 6395            'name': self.name,
 6396            'port': self.port,
 6397            'port_override': self.port_override,
 6398            'remote_identity_group_id': self.remote_identity_group_id,
 6399            'remote_identity_healthcheck_username':
 6400            self.remote_identity_healthcheck_username,
 6401            'secret_store_id': self.secret_store_id,
 6402            'tags': self.tags,
 6403        }
 6404
 6405    @classmethod
 6406    def from_dict(cls, d):
 6407        return cls(
 6408            bind_interface=d.get('bind_interface'),
 6409            certificate_authority=d.get('certificate_authority'),
 6410            client_certificate=d.get('client_certificate'),
 6411            client_key=d.get('client_key'),
 6412            egress_filter=d.get('egress_filter'),
 6413            healthcheck_namespace=d.get('healthcheck_namespace'),
 6414            healthy=d.get('healthy'),
 6415            hostname=d.get('hostname'),
 6416            id=d.get('id'),
 6417            name=d.get('name'),
 6418            port=d.get('port'),
 6419            port_override=d.get('port_override'),
 6420            remote_identity_group_id=d.get('remote_identity_group_id'),
 6421            remote_identity_healthcheck_username=d.get(
 6422                'remote_identity_healthcheck_username'),
 6423            secret_store_id=d.get('secret_store_id'),
 6424            tags=d.get('tags'),
 6425        )
 6426
 6427
 6428class KubernetesBasicAuth:
 6429    '''
 6430
 6431    '''
 6432    __slots__ = [
 6433        'bind_interface',
 6434        'egress_filter',
 6435        'healthcheck_namespace',
 6436        'healthy',
 6437        'hostname',
 6438        'id',
 6439        'name',
 6440        'password',
 6441        'port',
 6442        'port_override',
 6443        'secret_store_id',
 6444        'tags',
 6445        'username',
 6446    ]
 6447
 6448    def __init__(
 6449        self,
 6450        bind_interface=None,
 6451        egress_filter=None,
 6452        healthcheck_namespace=None,
 6453        healthy=None,
 6454        hostname=None,
 6455        id=None,
 6456        name=None,
 6457        password=None,
 6458        port=None,
 6459        port_override=None,
 6460        secret_store_id=None,
 6461        tags=None,
 6462        username=None,
 6463    ):
 6464        self.bind_interface = bind_interface if bind_interface is not None else ''
 6465        '''
 6466         Bind interface
 6467        '''
 6468        self.egress_filter = egress_filter if egress_filter is not None else ''
 6469        '''
 6470         A filter applied to the routing logic to pin datasource to nodes.
 6471        '''
 6472        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6473        '''
 6474         The path used to check the health of your connection.  Defaults to `default`.
 6475        '''
 6476        self.healthy = healthy if healthy is not None else False
 6477        '''
 6478         True if the datasource is reachable and the credentials are valid.
 6479        '''
 6480        self.hostname = hostname if hostname is not None else ''
 6481        '''
 6482
 6483        '''
 6484        self.id = id if id is not None else ''
 6485        '''
 6486         Unique identifier of the Resource.
 6487        '''
 6488        self.name = name if name is not None else ''
 6489        '''
 6490         Unique human-readable name of the Resource.
 6491        '''
 6492        self.password = password if password is not None else ''
 6493        '''
 6494
 6495        '''
 6496        self.port = port if port is not None else 0
 6497        '''
 6498
 6499        '''
 6500        self.port_override = port_override if port_override is not None else 0
 6501        '''
 6502
 6503        '''
 6504        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6505        '''
 6506         ID of the secret store containing credentials for this resource, if any.
 6507        '''
 6508        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6509        '''
 6510         Tags is a map of key, value pairs.
 6511        '''
 6512        self.username = username if username is not None else ''
 6513        '''
 6514
 6515        '''
 6516
 6517    def __repr__(self):
 6518        return '<sdm.KubernetesBasicAuth ' + \
 6519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6521            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6522            'healthy: ' + repr(self.healthy) + ' ' +\
 6523            'hostname: ' + repr(self.hostname) + ' ' +\
 6524            'id: ' + repr(self.id) + ' ' +\
 6525            'name: ' + repr(self.name) + ' ' +\
 6526            'password: ' + repr(self.password) + ' ' +\
 6527            'port: ' + repr(self.port) + ' ' +\
 6528            'port_override: ' + repr(self.port_override) + ' ' +\
 6529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6530            'tags: ' + repr(self.tags) + ' ' +\
 6531            'username: ' + repr(self.username) + ' ' +\
 6532            '>'
 6533
 6534    def to_dict(self):
 6535        return {
 6536            'bind_interface': self.bind_interface,
 6537            'egress_filter': self.egress_filter,
 6538            'healthcheck_namespace': self.healthcheck_namespace,
 6539            'healthy': self.healthy,
 6540            'hostname': self.hostname,
 6541            'id': self.id,
 6542            'name': self.name,
 6543            'password': self.password,
 6544            'port': self.port,
 6545            'port_override': self.port_override,
 6546            'secret_store_id': self.secret_store_id,
 6547            'tags': self.tags,
 6548            'username': self.username,
 6549        }
 6550
 6551    @classmethod
 6552    def from_dict(cls, d):
 6553        return cls(
 6554            bind_interface=d.get('bind_interface'),
 6555            egress_filter=d.get('egress_filter'),
 6556            healthcheck_namespace=d.get('healthcheck_namespace'),
 6557            healthy=d.get('healthy'),
 6558            hostname=d.get('hostname'),
 6559            id=d.get('id'),
 6560            name=d.get('name'),
 6561            password=d.get('password'),
 6562            port=d.get('port'),
 6563            port_override=d.get('port_override'),
 6564            secret_store_id=d.get('secret_store_id'),
 6565            tags=d.get('tags'),
 6566            username=d.get('username'),
 6567        )
 6568
 6569
 6570class KubernetesServiceAccount:
 6571    '''
 6572
 6573    '''
 6574    __slots__ = [
 6575        'bind_interface',
 6576        'egress_filter',
 6577        'healthcheck_namespace',
 6578        'healthy',
 6579        'hostname',
 6580        'id',
 6581        'name',
 6582        'port',
 6583        'port_override',
 6584        'remote_identity_group_id',
 6585        'remote_identity_healthcheck_username',
 6586        'secret_store_id',
 6587        'tags',
 6588        'token',
 6589    ]
 6590
 6591    def __init__(
 6592        self,
 6593        bind_interface=None,
 6594        egress_filter=None,
 6595        healthcheck_namespace=None,
 6596        healthy=None,
 6597        hostname=None,
 6598        id=None,
 6599        name=None,
 6600        port=None,
 6601        port_override=None,
 6602        remote_identity_group_id=None,
 6603        remote_identity_healthcheck_username=None,
 6604        secret_store_id=None,
 6605        tags=None,
 6606        token=None,
 6607    ):
 6608        self.bind_interface = bind_interface if bind_interface is not None else ''
 6609        '''
 6610         Bind interface
 6611        '''
 6612        self.egress_filter = egress_filter if egress_filter is not None else ''
 6613        '''
 6614         A filter applied to the routing logic to pin datasource to nodes.
 6615        '''
 6616        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6617        '''
 6618         The path used to check the health of your connection.  Defaults to `default`.
 6619        '''
 6620        self.healthy = healthy if healthy is not None else False
 6621        '''
 6622         True if the datasource is reachable and the credentials are valid.
 6623        '''
 6624        self.hostname = hostname if hostname is not None else ''
 6625        '''
 6626
 6627        '''
 6628        self.id = id if id is not None else ''
 6629        '''
 6630         Unique identifier of the Resource.
 6631        '''
 6632        self.name = name if name is not None else ''
 6633        '''
 6634         Unique human-readable name of the Resource.
 6635        '''
 6636        self.port = port if port is not None else 0
 6637        '''
 6638
 6639        '''
 6640        self.port_override = port_override if port_override is not None else 0
 6641        '''
 6642
 6643        '''
 6644        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6645        '''
 6646
 6647        '''
 6648        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6649        '''
 6650
 6651        '''
 6652        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6653        '''
 6654         ID of the secret store containing credentials for this resource, if any.
 6655        '''
 6656        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6657        '''
 6658         Tags is a map of key, value pairs.
 6659        '''
 6660        self.token = token if token is not None else ''
 6661        '''
 6662
 6663        '''
 6664
 6665    def __repr__(self):
 6666        return '<sdm.KubernetesServiceAccount ' + \
 6667            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6669            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6670            'healthy: ' + repr(self.healthy) + ' ' +\
 6671            'hostname: ' + repr(self.hostname) + ' ' +\
 6672            'id: ' + repr(self.id) + ' ' +\
 6673            'name: ' + repr(self.name) + ' ' +\
 6674            'port: ' + repr(self.port) + ' ' +\
 6675            'port_override: ' + repr(self.port_override) + ' ' +\
 6676            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6677            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6678            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6679            'tags: ' + repr(self.tags) + ' ' +\
 6680            'token: ' + repr(self.token) + ' ' +\
 6681            '>'
 6682
 6683    def to_dict(self):
 6684        return {
 6685            'bind_interface': self.bind_interface,
 6686            'egress_filter': self.egress_filter,
 6687            'healthcheck_namespace': self.healthcheck_namespace,
 6688            'healthy': self.healthy,
 6689            'hostname': self.hostname,
 6690            'id': self.id,
 6691            'name': self.name,
 6692            'port': self.port,
 6693            'port_override': self.port_override,
 6694            'remote_identity_group_id': self.remote_identity_group_id,
 6695            'remote_identity_healthcheck_username':
 6696            self.remote_identity_healthcheck_username,
 6697            'secret_store_id': self.secret_store_id,
 6698            'tags': self.tags,
 6699            'token': self.token,
 6700        }
 6701
 6702    @classmethod
 6703    def from_dict(cls, d):
 6704        return cls(
 6705            bind_interface=d.get('bind_interface'),
 6706            egress_filter=d.get('egress_filter'),
 6707            healthcheck_namespace=d.get('healthcheck_namespace'),
 6708            healthy=d.get('healthy'),
 6709            hostname=d.get('hostname'),
 6710            id=d.get('id'),
 6711            name=d.get('name'),
 6712            port=d.get('port'),
 6713            port_override=d.get('port_override'),
 6714            remote_identity_group_id=d.get('remote_identity_group_id'),
 6715            remote_identity_healthcheck_username=d.get(
 6716                'remote_identity_healthcheck_username'),
 6717            secret_store_id=d.get('secret_store_id'),
 6718            tags=d.get('tags'),
 6719            token=d.get('token'),
 6720        )
 6721
 6722
 6723class KubernetesServiceAccountUserImpersonation:
 6724    '''
 6725
 6726    '''
 6727    __slots__ = [
 6728        'bind_interface',
 6729        'egress_filter',
 6730        'healthcheck_namespace',
 6731        'healthy',
 6732        'hostname',
 6733        'id',
 6734        'name',
 6735        'port',
 6736        'port_override',
 6737        'secret_store_id',
 6738        'tags',
 6739        'token',
 6740    ]
 6741
 6742    def __init__(
 6743        self,
 6744        bind_interface=None,
 6745        egress_filter=None,
 6746        healthcheck_namespace=None,
 6747        healthy=None,
 6748        hostname=None,
 6749        id=None,
 6750        name=None,
 6751        port=None,
 6752        port_override=None,
 6753        secret_store_id=None,
 6754        tags=None,
 6755        token=None,
 6756    ):
 6757        self.bind_interface = bind_interface if bind_interface is not None else ''
 6758        '''
 6759         Bind interface
 6760        '''
 6761        self.egress_filter = egress_filter if egress_filter is not None else ''
 6762        '''
 6763         A filter applied to the routing logic to pin datasource to nodes.
 6764        '''
 6765        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6766        '''
 6767         The path used to check the health of your connection.  Defaults to `default`.
 6768        '''
 6769        self.healthy = healthy if healthy is not None else False
 6770        '''
 6771         True if the datasource is reachable and the credentials are valid.
 6772        '''
 6773        self.hostname = hostname if hostname is not None else ''
 6774        '''
 6775
 6776        '''
 6777        self.id = id if id is not None else ''
 6778        '''
 6779         Unique identifier of the Resource.
 6780        '''
 6781        self.name = name if name is not None else ''
 6782        '''
 6783         Unique human-readable name of the Resource.
 6784        '''
 6785        self.port = port if port is not None else 0
 6786        '''
 6787
 6788        '''
 6789        self.port_override = port_override if port_override is not None else 0
 6790        '''
 6791
 6792        '''
 6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6794        '''
 6795         ID of the secret store containing credentials for this resource, if any.
 6796        '''
 6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6798        '''
 6799         Tags is a map of key, value pairs.
 6800        '''
 6801        self.token = token if token is not None else ''
 6802        '''
 6803
 6804        '''
 6805
 6806    def __repr__(self):
 6807        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6808            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6809            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6810            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6811            'healthy: ' + repr(self.healthy) + ' ' +\
 6812            'hostname: ' + repr(self.hostname) + ' ' +\
 6813            'id: ' + repr(self.id) + ' ' +\
 6814            'name: ' + repr(self.name) + ' ' +\
 6815            'port: ' + repr(self.port) + ' ' +\
 6816            'port_override: ' + repr(self.port_override) + ' ' +\
 6817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6818            'tags: ' + repr(self.tags) + ' ' +\
 6819            'token: ' + repr(self.token) + ' ' +\
 6820            '>'
 6821
 6822    def to_dict(self):
 6823        return {
 6824            'bind_interface': self.bind_interface,
 6825            'egress_filter': self.egress_filter,
 6826            'healthcheck_namespace': self.healthcheck_namespace,
 6827            'healthy': self.healthy,
 6828            'hostname': self.hostname,
 6829            'id': self.id,
 6830            'name': self.name,
 6831            'port': self.port,
 6832            'port_override': self.port_override,
 6833            'secret_store_id': self.secret_store_id,
 6834            'tags': self.tags,
 6835            'token': self.token,
 6836        }
 6837
 6838    @classmethod
 6839    def from_dict(cls, d):
 6840        return cls(
 6841            bind_interface=d.get('bind_interface'),
 6842            egress_filter=d.get('egress_filter'),
 6843            healthcheck_namespace=d.get('healthcheck_namespace'),
 6844            healthy=d.get('healthy'),
 6845            hostname=d.get('hostname'),
 6846            id=d.get('id'),
 6847            name=d.get('name'),
 6848            port=d.get('port'),
 6849            port_override=d.get('port_override'),
 6850            secret_store_id=d.get('secret_store_id'),
 6851            tags=d.get('tags'),
 6852            token=d.get('token'),
 6853        )
 6854
 6855
 6856class KubernetesUserImpersonation:
 6857    '''
 6858
 6859    '''
 6860    __slots__ = [
 6861        'bind_interface',
 6862        'certificate_authority',
 6863        'client_certificate',
 6864        'client_key',
 6865        'egress_filter',
 6866        'healthcheck_namespace',
 6867        'healthy',
 6868        'hostname',
 6869        'id',
 6870        'name',
 6871        'port',
 6872        'port_override',
 6873        'secret_store_id',
 6874        'tags',
 6875    ]
 6876
 6877    def __init__(
 6878        self,
 6879        bind_interface=None,
 6880        certificate_authority=None,
 6881        client_certificate=None,
 6882        client_key=None,
 6883        egress_filter=None,
 6884        healthcheck_namespace=None,
 6885        healthy=None,
 6886        hostname=None,
 6887        id=None,
 6888        name=None,
 6889        port=None,
 6890        port_override=None,
 6891        secret_store_id=None,
 6892        tags=None,
 6893    ):
 6894        self.bind_interface = bind_interface if bind_interface is not None else ''
 6895        '''
 6896         Bind interface
 6897        '''
 6898        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6899        '''
 6900
 6901        '''
 6902        self.client_certificate = client_certificate if client_certificate is not None else ''
 6903        '''
 6904
 6905        '''
 6906        self.client_key = client_key if client_key is not None else ''
 6907        '''
 6908
 6909        '''
 6910        self.egress_filter = egress_filter if egress_filter is not None else ''
 6911        '''
 6912         A filter applied to the routing logic to pin datasource to nodes.
 6913        '''
 6914        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6915        '''
 6916         The path used to check the health of your connection.  Defaults to `default`.
 6917        '''
 6918        self.healthy = healthy if healthy is not None else False
 6919        '''
 6920         True if the datasource is reachable and the credentials are valid.
 6921        '''
 6922        self.hostname = hostname if hostname is not None else ''
 6923        '''
 6924
 6925        '''
 6926        self.id = id if id is not None else ''
 6927        '''
 6928         Unique identifier of the Resource.
 6929        '''
 6930        self.name = name if name is not None else ''
 6931        '''
 6932         Unique human-readable name of the Resource.
 6933        '''
 6934        self.port = port if port is not None else 0
 6935        '''
 6936
 6937        '''
 6938        self.port_override = port_override if port_override is not None else 0
 6939        '''
 6940
 6941        '''
 6942        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6943        '''
 6944         ID of the secret store containing credentials for this resource, if any.
 6945        '''
 6946        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6947        '''
 6948         Tags is a map of key, value pairs.
 6949        '''
 6950
 6951    def __repr__(self):
 6952        return '<sdm.KubernetesUserImpersonation ' + \
 6953            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6954            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6955            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6956            'client_key: ' + repr(self.client_key) + ' ' +\
 6957            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6958            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6959            'healthy: ' + repr(self.healthy) + ' ' +\
 6960            'hostname: ' + repr(self.hostname) + ' ' +\
 6961            'id: ' + repr(self.id) + ' ' +\
 6962            'name: ' + repr(self.name) + ' ' +\
 6963            'port: ' + repr(self.port) + ' ' +\
 6964            'port_override: ' + repr(self.port_override) + ' ' +\
 6965            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6966            'tags: ' + repr(self.tags) + ' ' +\
 6967            '>'
 6968
 6969    def to_dict(self):
 6970        return {
 6971            'bind_interface': self.bind_interface,
 6972            'certificate_authority': self.certificate_authority,
 6973            'client_certificate': self.client_certificate,
 6974            'client_key': self.client_key,
 6975            'egress_filter': self.egress_filter,
 6976            'healthcheck_namespace': self.healthcheck_namespace,
 6977            'healthy': self.healthy,
 6978            'hostname': self.hostname,
 6979            'id': self.id,
 6980            'name': self.name,
 6981            'port': self.port,
 6982            'port_override': self.port_override,
 6983            'secret_store_id': self.secret_store_id,
 6984            'tags': self.tags,
 6985        }
 6986
 6987    @classmethod
 6988    def from_dict(cls, d):
 6989        return cls(
 6990            bind_interface=d.get('bind_interface'),
 6991            certificate_authority=d.get('certificate_authority'),
 6992            client_certificate=d.get('client_certificate'),
 6993            client_key=d.get('client_key'),
 6994            egress_filter=d.get('egress_filter'),
 6995            healthcheck_namespace=d.get('healthcheck_namespace'),
 6996            healthy=d.get('healthy'),
 6997            hostname=d.get('hostname'),
 6998            id=d.get('id'),
 6999            name=d.get('name'),
 7000            port=d.get('port'),
 7001            port_override=d.get('port_override'),
 7002            secret_store_id=d.get('secret_store_id'),
 7003            tags=d.get('tags'),
 7004        )
 7005
 7006
 7007class MTLSMysql:
 7008    '''
 7009
 7010    '''
 7011    __slots__ = [
 7012        'bind_interface',
 7013        'certificate_authority',
 7014        'client_certificate',
 7015        'client_key',
 7016        'database',
 7017        'egress_filter',
 7018        'healthy',
 7019        'hostname',
 7020        'id',
 7021        'name',
 7022        'password',
 7023        'port',
 7024        'port_override',
 7025        'secret_store_id',
 7026        'server_name',
 7027        'tags',
 7028        'username',
 7029    ]
 7030
 7031    def __init__(
 7032        self,
 7033        bind_interface=None,
 7034        certificate_authority=None,
 7035        client_certificate=None,
 7036        client_key=None,
 7037        database=None,
 7038        egress_filter=None,
 7039        healthy=None,
 7040        hostname=None,
 7041        id=None,
 7042        name=None,
 7043        password=None,
 7044        port=None,
 7045        port_override=None,
 7046        secret_store_id=None,
 7047        server_name=None,
 7048        tags=None,
 7049        username=None,
 7050    ):
 7051        self.bind_interface = bind_interface if bind_interface is not None else ''
 7052        '''
 7053         Bind interface
 7054        '''
 7055        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7056        '''
 7057
 7058        '''
 7059        self.client_certificate = client_certificate if client_certificate is not None else ''
 7060        '''
 7061
 7062        '''
 7063        self.client_key = client_key if client_key is not None else ''
 7064        '''
 7065
 7066        '''
 7067        self.database = database if database is not None else ''
 7068        '''
 7069
 7070        '''
 7071        self.egress_filter = egress_filter if egress_filter is not None else ''
 7072        '''
 7073         A filter applied to the routing logic to pin datasource to nodes.
 7074        '''
 7075        self.healthy = healthy if healthy is not None else False
 7076        '''
 7077         True if the datasource is reachable and the credentials are valid.
 7078        '''
 7079        self.hostname = hostname if hostname is not None else ''
 7080        '''
 7081
 7082        '''
 7083        self.id = id if id is not None else ''
 7084        '''
 7085         Unique identifier of the Resource.
 7086        '''
 7087        self.name = name if name is not None else ''
 7088        '''
 7089         Unique human-readable name of the Resource.
 7090        '''
 7091        self.password = password if password is not None else ''
 7092        '''
 7093
 7094        '''
 7095        self.port = port if port is not None else 0
 7096        '''
 7097
 7098        '''
 7099        self.port_override = port_override if port_override is not None else 0
 7100        '''
 7101
 7102        '''
 7103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7104        '''
 7105         ID of the secret store containing credentials for this resource, if any.
 7106        '''
 7107        self.server_name = server_name if server_name is not None else ''
 7108        '''
 7109
 7110        '''
 7111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7112        '''
 7113         Tags is a map of key, value pairs.
 7114        '''
 7115        self.username = username if username is not None else ''
 7116        '''
 7117
 7118        '''
 7119
 7120    def __repr__(self):
 7121        return '<sdm.MTLSMysql ' + \
 7122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7123            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7124            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7125            'client_key: ' + repr(self.client_key) + ' ' +\
 7126            'database: ' + repr(self.database) + ' ' +\
 7127            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7128            'healthy: ' + repr(self.healthy) + ' ' +\
 7129            'hostname: ' + repr(self.hostname) + ' ' +\
 7130            'id: ' + repr(self.id) + ' ' +\
 7131            'name: ' + repr(self.name) + ' ' +\
 7132            'password: ' + repr(self.password) + ' ' +\
 7133            'port: ' + repr(self.port) + ' ' +\
 7134            'port_override: ' + repr(self.port_override) + ' ' +\
 7135            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7136            'server_name: ' + repr(self.server_name) + ' ' +\
 7137            'tags: ' + repr(self.tags) + ' ' +\
 7138            'username: ' + repr(self.username) + ' ' +\
 7139            '>'
 7140
 7141    def to_dict(self):
 7142        return {
 7143            'bind_interface': self.bind_interface,
 7144            'certificate_authority': self.certificate_authority,
 7145            'client_certificate': self.client_certificate,
 7146            'client_key': self.client_key,
 7147            'database': self.database,
 7148            'egress_filter': self.egress_filter,
 7149            'healthy': self.healthy,
 7150            'hostname': self.hostname,
 7151            'id': self.id,
 7152            'name': self.name,
 7153            'password': self.password,
 7154            'port': self.port,
 7155            'port_override': self.port_override,
 7156            'secret_store_id': self.secret_store_id,
 7157            'server_name': self.server_name,
 7158            'tags': self.tags,
 7159            'username': self.username,
 7160        }
 7161
 7162    @classmethod
 7163    def from_dict(cls, d):
 7164        return cls(
 7165            bind_interface=d.get('bind_interface'),
 7166            certificate_authority=d.get('certificate_authority'),
 7167            client_certificate=d.get('client_certificate'),
 7168            client_key=d.get('client_key'),
 7169            database=d.get('database'),
 7170            egress_filter=d.get('egress_filter'),
 7171            healthy=d.get('healthy'),
 7172            hostname=d.get('hostname'),
 7173            id=d.get('id'),
 7174            name=d.get('name'),
 7175            password=d.get('password'),
 7176            port=d.get('port'),
 7177            port_override=d.get('port_override'),
 7178            secret_store_id=d.get('secret_store_id'),
 7179            server_name=d.get('server_name'),
 7180            tags=d.get('tags'),
 7181            username=d.get('username'),
 7182        )
 7183
 7184
 7185class MTLSPostgres:
 7186    '''
 7187
 7188    '''
 7189    __slots__ = [
 7190        'bind_interface',
 7191        'certificate_authority',
 7192        'client_certificate',
 7193        'client_key',
 7194        'database',
 7195        'egress_filter',
 7196        'healthy',
 7197        'hostname',
 7198        'id',
 7199        'name',
 7200        'override_database',
 7201        'password',
 7202        'port',
 7203        'port_override',
 7204        'secret_store_id',
 7205        'server_name',
 7206        'tags',
 7207        'username',
 7208    ]
 7209
 7210    def __init__(
 7211        self,
 7212        bind_interface=None,
 7213        certificate_authority=None,
 7214        client_certificate=None,
 7215        client_key=None,
 7216        database=None,
 7217        egress_filter=None,
 7218        healthy=None,
 7219        hostname=None,
 7220        id=None,
 7221        name=None,
 7222        override_database=None,
 7223        password=None,
 7224        port=None,
 7225        port_override=None,
 7226        secret_store_id=None,
 7227        server_name=None,
 7228        tags=None,
 7229        username=None,
 7230    ):
 7231        self.bind_interface = bind_interface if bind_interface is not None else ''
 7232        '''
 7233         Bind interface
 7234        '''
 7235        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7236        '''
 7237
 7238        '''
 7239        self.client_certificate = client_certificate if client_certificate is not None else ''
 7240        '''
 7241
 7242        '''
 7243        self.client_key = client_key if client_key is not None else ''
 7244        '''
 7245
 7246        '''
 7247        self.database = database if database is not None else ''
 7248        '''
 7249
 7250        '''
 7251        self.egress_filter = egress_filter if egress_filter is not None else ''
 7252        '''
 7253         A filter applied to the routing logic to pin datasource to nodes.
 7254        '''
 7255        self.healthy = healthy if healthy is not None else False
 7256        '''
 7257         True if the datasource is reachable and the credentials are valid.
 7258        '''
 7259        self.hostname = hostname if hostname is not None else ''
 7260        '''
 7261
 7262        '''
 7263        self.id = id if id is not None else ''
 7264        '''
 7265         Unique identifier of the Resource.
 7266        '''
 7267        self.name = name if name is not None else ''
 7268        '''
 7269         Unique human-readable name of the Resource.
 7270        '''
 7271        self.override_database = override_database if override_database is not None else False
 7272        '''
 7273
 7274        '''
 7275        self.password = password if password is not None else ''
 7276        '''
 7277
 7278        '''
 7279        self.port = port if port is not None else 0
 7280        '''
 7281
 7282        '''
 7283        self.port_override = port_override if port_override is not None else 0
 7284        '''
 7285
 7286        '''
 7287        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7288        '''
 7289         ID of the secret store containing credentials for this resource, if any.
 7290        '''
 7291        self.server_name = server_name if server_name is not None else ''
 7292        '''
 7293
 7294        '''
 7295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7296        '''
 7297         Tags is a map of key, value pairs.
 7298        '''
 7299        self.username = username if username is not None else ''
 7300        '''
 7301
 7302        '''
 7303
 7304    def __repr__(self):
 7305        return '<sdm.MTLSPostgres ' + \
 7306            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7307            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7308            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7309            'client_key: ' + repr(self.client_key) + ' ' +\
 7310            'database: ' + repr(self.database) + ' ' +\
 7311            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7312            'healthy: ' + repr(self.healthy) + ' ' +\
 7313            'hostname: ' + repr(self.hostname) + ' ' +\
 7314            'id: ' + repr(self.id) + ' ' +\
 7315            'name: ' + repr(self.name) + ' ' +\
 7316            'override_database: ' + repr(self.override_database) + ' ' +\
 7317            'password: ' + repr(self.password) + ' ' +\
 7318            'port: ' + repr(self.port) + ' ' +\
 7319            'port_override: ' + repr(self.port_override) + ' ' +\
 7320            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7321            'server_name: ' + repr(self.server_name) + ' ' +\
 7322            'tags: ' + repr(self.tags) + ' ' +\
 7323            'username: ' + repr(self.username) + ' ' +\
 7324            '>'
 7325
 7326    def to_dict(self):
 7327        return {
 7328            'bind_interface': self.bind_interface,
 7329            'certificate_authority': self.certificate_authority,
 7330            'client_certificate': self.client_certificate,
 7331            'client_key': self.client_key,
 7332            'database': self.database,
 7333            'egress_filter': self.egress_filter,
 7334            'healthy': self.healthy,
 7335            'hostname': self.hostname,
 7336            'id': self.id,
 7337            'name': self.name,
 7338            'override_database': self.override_database,
 7339            'password': self.password,
 7340            'port': self.port,
 7341            'port_override': self.port_override,
 7342            'secret_store_id': self.secret_store_id,
 7343            'server_name': self.server_name,
 7344            'tags': self.tags,
 7345            'username': self.username,
 7346        }
 7347
 7348    @classmethod
 7349    def from_dict(cls, d):
 7350        return cls(
 7351            bind_interface=d.get('bind_interface'),
 7352            certificate_authority=d.get('certificate_authority'),
 7353            client_certificate=d.get('client_certificate'),
 7354            client_key=d.get('client_key'),
 7355            database=d.get('database'),
 7356            egress_filter=d.get('egress_filter'),
 7357            healthy=d.get('healthy'),
 7358            hostname=d.get('hostname'),
 7359            id=d.get('id'),
 7360            name=d.get('name'),
 7361            override_database=d.get('override_database'),
 7362            password=d.get('password'),
 7363            port=d.get('port'),
 7364            port_override=d.get('port_override'),
 7365            secret_store_id=d.get('secret_store_id'),
 7366            server_name=d.get('server_name'),
 7367            tags=d.get('tags'),
 7368            username=d.get('username'),
 7369        )
 7370
 7371
 7372class Maria:
 7373    '''
 7374
 7375    '''
 7376    __slots__ = [
 7377        'bind_interface',
 7378        'database',
 7379        'egress_filter',
 7380        'healthy',
 7381        'hostname',
 7382        'id',
 7383        'name',
 7384        'password',
 7385        'port',
 7386        'port_override',
 7387        'secret_store_id',
 7388        'tags',
 7389        'username',
 7390    ]
 7391
 7392    def __init__(
 7393        self,
 7394        bind_interface=None,
 7395        database=None,
 7396        egress_filter=None,
 7397        healthy=None,
 7398        hostname=None,
 7399        id=None,
 7400        name=None,
 7401        password=None,
 7402        port=None,
 7403        port_override=None,
 7404        secret_store_id=None,
 7405        tags=None,
 7406        username=None,
 7407    ):
 7408        self.bind_interface = bind_interface if bind_interface is not None else ''
 7409        '''
 7410         Bind interface
 7411        '''
 7412        self.database = database if database is not None else ''
 7413        '''
 7414
 7415        '''
 7416        self.egress_filter = egress_filter if egress_filter is not None else ''
 7417        '''
 7418         A filter applied to the routing logic to pin datasource to nodes.
 7419        '''
 7420        self.healthy = healthy if healthy is not None else False
 7421        '''
 7422         True if the datasource is reachable and the credentials are valid.
 7423        '''
 7424        self.hostname = hostname if hostname is not None else ''
 7425        '''
 7426
 7427        '''
 7428        self.id = id if id is not None else ''
 7429        '''
 7430         Unique identifier of the Resource.
 7431        '''
 7432        self.name = name if name is not None else ''
 7433        '''
 7434         Unique human-readable name of the Resource.
 7435        '''
 7436        self.password = password if password is not None else ''
 7437        '''
 7438
 7439        '''
 7440        self.port = port if port is not None else 0
 7441        '''
 7442
 7443        '''
 7444        self.port_override = port_override if port_override is not None else 0
 7445        '''
 7446
 7447        '''
 7448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7449        '''
 7450         ID of the secret store containing credentials for this resource, if any.
 7451        '''
 7452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7453        '''
 7454         Tags is a map of key, value pairs.
 7455        '''
 7456        self.username = username if username is not None else ''
 7457        '''
 7458
 7459        '''
 7460
 7461    def __repr__(self):
 7462        return '<sdm.Maria ' + \
 7463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7464            'database: ' + repr(self.database) + ' ' +\
 7465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7466            'healthy: ' + repr(self.healthy) + ' ' +\
 7467            'hostname: ' + repr(self.hostname) + ' ' +\
 7468            'id: ' + repr(self.id) + ' ' +\
 7469            'name: ' + repr(self.name) + ' ' +\
 7470            'password: ' + repr(self.password) + ' ' +\
 7471            'port: ' + repr(self.port) + ' ' +\
 7472            'port_override: ' + repr(self.port_override) + ' ' +\
 7473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7474            'tags: ' + repr(self.tags) + ' ' +\
 7475            'username: ' + repr(self.username) + ' ' +\
 7476            '>'
 7477
 7478    def to_dict(self):
 7479        return {
 7480            'bind_interface': self.bind_interface,
 7481            'database': self.database,
 7482            'egress_filter': self.egress_filter,
 7483            'healthy': self.healthy,
 7484            'hostname': self.hostname,
 7485            'id': self.id,
 7486            'name': self.name,
 7487            'password': self.password,
 7488            'port': self.port,
 7489            'port_override': self.port_override,
 7490            'secret_store_id': self.secret_store_id,
 7491            'tags': self.tags,
 7492            'username': self.username,
 7493        }
 7494
 7495    @classmethod
 7496    def from_dict(cls, d):
 7497        return cls(
 7498            bind_interface=d.get('bind_interface'),
 7499            database=d.get('database'),
 7500            egress_filter=d.get('egress_filter'),
 7501            healthy=d.get('healthy'),
 7502            hostname=d.get('hostname'),
 7503            id=d.get('id'),
 7504            name=d.get('name'),
 7505            password=d.get('password'),
 7506            port=d.get('port'),
 7507            port_override=d.get('port_override'),
 7508            secret_store_id=d.get('secret_store_id'),
 7509            tags=d.get('tags'),
 7510            username=d.get('username'),
 7511        )
 7512
 7513
 7514class Memcached:
 7515    '''
 7516
 7517    '''
 7518    __slots__ = [
 7519        'bind_interface',
 7520        'egress_filter',
 7521        'healthy',
 7522        'hostname',
 7523        'id',
 7524        'name',
 7525        'port',
 7526        'port_override',
 7527        'secret_store_id',
 7528        'tags',
 7529    ]
 7530
 7531    def __init__(
 7532        self,
 7533        bind_interface=None,
 7534        egress_filter=None,
 7535        healthy=None,
 7536        hostname=None,
 7537        id=None,
 7538        name=None,
 7539        port=None,
 7540        port_override=None,
 7541        secret_store_id=None,
 7542        tags=None,
 7543    ):
 7544        self.bind_interface = bind_interface if bind_interface is not None else ''
 7545        '''
 7546         Bind interface
 7547        '''
 7548        self.egress_filter = egress_filter if egress_filter is not None else ''
 7549        '''
 7550         A filter applied to the routing logic to pin datasource to nodes.
 7551        '''
 7552        self.healthy = healthy if healthy is not None else False
 7553        '''
 7554         True if the datasource is reachable and the credentials are valid.
 7555        '''
 7556        self.hostname = hostname if hostname is not None else ''
 7557        '''
 7558
 7559        '''
 7560        self.id = id if id is not None else ''
 7561        '''
 7562         Unique identifier of the Resource.
 7563        '''
 7564        self.name = name if name is not None else ''
 7565        '''
 7566         Unique human-readable name of the Resource.
 7567        '''
 7568        self.port = port if port is not None else 0
 7569        '''
 7570
 7571        '''
 7572        self.port_override = port_override if port_override is not None else 0
 7573        '''
 7574
 7575        '''
 7576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7577        '''
 7578         ID of the secret store containing credentials for this resource, if any.
 7579        '''
 7580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7581        '''
 7582         Tags is a map of key, value pairs.
 7583        '''
 7584
 7585    def __repr__(self):
 7586        return '<sdm.Memcached ' + \
 7587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7588            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7589            'healthy: ' + repr(self.healthy) + ' ' +\
 7590            'hostname: ' + repr(self.hostname) + ' ' +\
 7591            'id: ' + repr(self.id) + ' ' +\
 7592            'name: ' + repr(self.name) + ' ' +\
 7593            'port: ' + repr(self.port) + ' ' +\
 7594            'port_override: ' + repr(self.port_override) + ' ' +\
 7595            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7596            'tags: ' + repr(self.tags) + ' ' +\
 7597            '>'
 7598
 7599    def to_dict(self):
 7600        return {
 7601            'bind_interface': self.bind_interface,
 7602            'egress_filter': self.egress_filter,
 7603            'healthy': self.healthy,
 7604            'hostname': self.hostname,
 7605            'id': self.id,
 7606            'name': self.name,
 7607            'port': self.port,
 7608            'port_override': self.port_override,
 7609            'secret_store_id': self.secret_store_id,
 7610            'tags': self.tags,
 7611        }
 7612
 7613    @classmethod
 7614    def from_dict(cls, d):
 7615        return cls(
 7616            bind_interface=d.get('bind_interface'),
 7617            egress_filter=d.get('egress_filter'),
 7618            healthy=d.get('healthy'),
 7619            hostname=d.get('hostname'),
 7620            id=d.get('id'),
 7621            name=d.get('name'),
 7622            port=d.get('port'),
 7623            port_override=d.get('port_override'),
 7624            secret_store_id=d.get('secret_store_id'),
 7625            tags=d.get('tags'),
 7626        )
 7627
 7628
 7629class Memsql:
 7630    '''
 7631
 7632    '''
 7633    __slots__ = [
 7634        'bind_interface',
 7635        'database',
 7636        'egress_filter',
 7637        'healthy',
 7638        'hostname',
 7639        'id',
 7640        'name',
 7641        'password',
 7642        'port',
 7643        'port_override',
 7644        'secret_store_id',
 7645        'tags',
 7646        'username',
 7647    ]
 7648
 7649    def __init__(
 7650        self,
 7651        bind_interface=None,
 7652        database=None,
 7653        egress_filter=None,
 7654        healthy=None,
 7655        hostname=None,
 7656        id=None,
 7657        name=None,
 7658        password=None,
 7659        port=None,
 7660        port_override=None,
 7661        secret_store_id=None,
 7662        tags=None,
 7663        username=None,
 7664    ):
 7665        self.bind_interface = bind_interface if bind_interface is not None else ''
 7666        '''
 7667         Bind interface
 7668        '''
 7669        self.database = database if database is not None else ''
 7670        '''
 7671
 7672        '''
 7673        self.egress_filter = egress_filter if egress_filter is not None else ''
 7674        '''
 7675         A filter applied to the routing logic to pin datasource to nodes.
 7676        '''
 7677        self.healthy = healthy if healthy is not None else False
 7678        '''
 7679         True if the datasource is reachable and the credentials are valid.
 7680        '''
 7681        self.hostname = hostname if hostname is not None else ''
 7682        '''
 7683
 7684        '''
 7685        self.id = id if id is not None else ''
 7686        '''
 7687         Unique identifier of the Resource.
 7688        '''
 7689        self.name = name if name is not None else ''
 7690        '''
 7691         Unique human-readable name of the Resource.
 7692        '''
 7693        self.password = password if password is not None else ''
 7694        '''
 7695
 7696        '''
 7697        self.port = port if port is not None else 0
 7698        '''
 7699
 7700        '''
 7701        self.port_override = port_override if port_override is not None else 0
 7702        '''
 7703
 7704        '''
 7705        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7706        '''
 7707         ID of the secret store containing credentials for this resource, if any.
 7708        '''
 7709        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7710        '''
 7711         Tags is a map of key, value pairs.
 7712        '''
 7713        self.username = username if username is not None else ''
 7714        '''
 7715
 7716        '''
 7717
 7718    def __repr__(self):
 7719        return '<sdm.Memsql ' + \
 7720            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7721            'database: ' + repr(self.database) + ' ' +\
 7722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7723            'healthy: ' + repr(self.healthy) + ' ' +\
 7724            'hostname: ' + repr(self.hostname) + ' ' +\
 7725            'id: ' + repr(self.id) + ' ' +\
 7726            'name: ' + repr(self.name) + ' ' +\
 7727            'password: ' + repr(self.password) + ' ' +\
 7728            'port: ' + repr(self.port) + ' ' +\
 7729            'port_override: ' + repr(self.port_override) + ' ' +\
 7730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7731            'tags: ' + repr(self.tags) + ' ' +\
 7732            'username: ' + repr(self.username) + ' ' +\
 7733            '>'
 7734
 7735    def to_dict(self):
 7736        return {
 7737            'bind_interface': self.bind_interface,
 7738            'database': self.database,
 7739            'egress_filter': self.egress_filter,
 7740            'healthy': self.healthy,
 7741            'hostname': self.hostname,
 7742            'id': self.id,
 7743            'name': self.name,
 7744            'password': self.password,
 7745            'port': self.port,
 7746            'port_override': self.port_override,
 7747            'secret_store_id': self.secret_store_id,
 7748            'tags': self.tags,
 7749            'username': self.username,
 7750        }
 7751
 7752    @classmethod
 7753    def from_dict(cls, d):
 7754        return cls(
 7755            bind_interface=d.get('bind_interface'),
 7756            database=d.get('database'),
 7757            egress_filter=d.get('egress_filter'),
 7758            healthy=d.get('healthy'),
 7759            hostname=d.get('hostname'),
 7760            id=d.get('id'),
 7761            name=d.get('name'),
 7762            password=d.get('password'),
 7763            port=d.get('port'),
 7764            port_override=d.get('port_override'),
 7765            secret_store_id=d.get('secret_store_id'),
 7766            tags=d.get('tags'),
 7767            username=d.get('username'),
 7768        )
 7769
 7770
 7771class MongoHost:
 7772    '''
 7773
 7774    '''
 7775    __slots__ = [
 7776        'auth_database',
 7777        'bind_interface',
 7778        'egress_filter',
 7779        'healthy',
 7780        'hostname',
 7781        'id',
 7782        'name',
 7783        'password',
 7784        'port',
 7785        'port_override',
 7786        'secret_store_id',
 7787        'tags',
 7788        'tls_required',
 7789        'username',
 7790    ]
 7791
 7792    def __init__(
 7793        self,
 7794        auth_database=None,
 7795        bind_interface=None,
 7796        egress_filter=None,
 7797        healthy=None,
 7798        hostname=None,
 7799        id=None,
 7800        name=None,
 7801        password=None,
 7802        port=None,
 7803        port_override=None,
 7804        secret_store_id=None,
 7805        tags=None,
 7806        tls_required=None,
 7807        username=None,
 7808    ):
 7809        self.auth_database = auth_database if auth_database is not None else ''
 7810        '''
 7811
 7812        '''
 7813        self.bind_interface = bind_interface if bind_interface is not None else ''
 7814        '''
 7815         Bind interface
 7816        '''
 7817        self.egress_filter = egress_filter if egress_filter is not None else ''
 7818        '''
 7819         A filter applied to the routing logic to pin datasource to nodes.
 7820        '''
 7821        self.healthy = healthy if healthy is not None else False
 7822        '''
 7823         True if the datasource is reachable and the credentials are valid.
 7824        '''
 7825        self.hostname = hostname if hostname is not None else ''
 7826        '''
 7827
 7828        '''
 7829        self.id = id if id is not None else ''
 7830        '''
 7831         Unique identifier of the Resource.
 7832        '''
 7833        self.name = name if name is not None else ''
 7834        '''
 7835         Unique human-readable name of the Resource.
 7836        '''
 7837        self.password = password if password is not None else ''
 7838        '''
 7839
 7840        '''
 7841        self.port = port if port is not None else 0
 7842        '''
 7843
 7844        '''
 7845        self.port_override = port_override if port_override is not None else 0
 7846        '''
 7847
 7848        '''
 7849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7850        '''
 7851         ID of the secret store containing credentials for this resource, if any.
 7852        '''
 7853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7854        '''
 7855         Tags is a map of key, value pairs.
 7856        '''
 7857        self.tls_required = tls_required if tls_required is not None else False
 7858        '''
 7859
 7860        '''
 7861        self.username = username if username is not None else ''
 7862        '''
 7863
 7864        '''
 7865
 7866    def __repr__(self):
 7867        return '<sdm.MongoHost ' + \
 7868            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7871            'healthy: ' + repr(self.healthy) + ' ' +\
 7872            'hostname: ' + repr(self.hostname) + ' ' +\
 7873            'id: ' + repr(self.id) + ' ' +\
 7874            'name: ' + repr(self.name) + ' ' +\
 7875            'password: ' + repr(self.password) + ' ' +\
 7876            'port: ' + repr(self.port) + ' ' +\
 7877            'port_override: ' + repr(self.port_override) + ' ' +\
 7878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7879            'tags: ' + repr(self.tags) + ' ' +\
 7880            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7881            'username: ' + repr(self.username) + ' ' +\
 7882            '>'
 7883
 7884    def to_dict(self):
 7885        return {
 7886            'auth_database': self.auth_database,
 7887            'bind_interface': self.bind_interface,
 7888            'egress_filter': self.egress_filter,
 7889            'healthy': self.healthy,
 7890            'hostname': self.hostname,
 7891            'id': self.id,
 7892            'name': self.name,
 7893            'password': self.password,
 7894            'port': self.port,
 7895            'port_override': self.port_override,
 7896            'secret_store_id': self.secret_store_id,
 7897            'tags': self.tags,
 7898            'tls_required': self.tls_required,
 7899            'username': self.username,
 7900        }
 7901
 7902    @classmethod
 7903    def from_dict(cls, d):
 7904        return cls(
 7905            auth_database=d.get('auth_database'),
 7906            bind_interface=d.get('bind_interface'),
 7907            egress_filter=d.get('egress_filter'),
 7908            healthy=d.get('healthy'),
 7909            hostname=d.get('hostname'),
 7910            id=d.get('id'),
 7911            name=d.get('name'),
 7912            password=d.get('password'),
 7913            port=d.get('port'),
 7914            port_override=d.get('port_override'),
 7915            secret_store_id=d.get('secret_store_id'),
 7916            tags=d.get('tags'),
 7917            tls_required=d.get('tls_required'),
 7918            username=d.get('username'),
 7919        )
 7920
 7921
 7922class MongoLegacyHost:
 7923    '''
 7924
 7925    '''
 7926    __slots__ = [
 7927        'auth_database',
 7928        'bind_interface',
 7929        'egress_filter',
 7930        'healthy',
 7931        'hostname',
 7932        'id',
 7933        'name',
 7934        'password',
 7935        'port',
 7936        'port_override',
 7937        'replica_set',
 7938        'secret_store_id',
 7939        'tags',
 7940        'tls_required',
 7941        'username',
 7942    ]
 7943
 7944    def __init__(
 7945        self,
 7946        auth_database=None,
 7947        bind_interface=None,
 7948        egress_filter=None,
 7949        healthy=None,
 7950        hostname=None,
 7951        id=None,
 7952        name=None,
 7953        password=None,
 7954        port=None,
 7955        port_override=None,
 7956        replica_set=None,
 7957        secret_store_id=None,
 7958        tags=None,
 7959        tls_required=None,
 7960        username=None,
 7961    ):
 7962        self.auth_database = auth_database if auth_database is not None else ''
 7963        '''
 7964
 7965        '''
 7966        self.bind_interface = bind_interface if bind_interface is not None else ''
 7967        '''
 7968         Bind interface
 7969        '''
 7970        self.egress_filter = egress_filter if egress_filter is not None else ''
 7971        '''
 7972         A filter applied to the routing logic to pin datasource to nodes.
 7973        '''
 7974        self.healthy = healthy if healthy is not None else False
 7975        '''
 7976         True if the datasource is reachable and the credentials are valid.
 7977        '''
 7978        self.hostname = hostname if hostname is not None else ''
 7979        '''
 7980
 7981        '''
 7982        self.id = id if id is not None else ''
 7983        '''
 7984         Unique identifier of the Resource.
 7985        '''
 7986        self.name = name if name is not None else ''
 7987        '''
 7988         Unique human-readable name of the Resource.
 7989        '''
 7990        self.password = password if password is not None else ''
 7991        '''
 7992
 7993        '''
 7994        self.port = port if port is not None else 0
 7995        '''
 7996
 7997        '''
 7998        self.port_override = port_override if port_override is not None else 0
 7999        '''
 8000
 8001        '''
 8002        self.replica_set = replica_set if replica_set is not None else ''
 8003        '''
 8004
 8005        '''
 8006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8007        '''
 8008         ID of the secret store containing credentials for this resource, if any.
 8009        '''
 8010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8011        '''
 8012         Tags is a map of key, value pairs.
 8013        '''
 8014        self.tls_required = tls_required if tls_required is not None else False
 8015        '''
 8016
 8017        '''
 8018        self.username = username if username is not None else ''
 8019        '''
 8020
 8021        '''
 8022
 8023    def __repr__(self):
 8024        return '<sdm.MongoLegacyHost ' + \
 8025            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8026            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8027            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8028            'healthy: ' + repr(self.healthy) + ' ' +\
 8029            'hostname: ' + repr(self.hostname) + ' ' +\
 8030            'id: ' + repr(self.id) + ' ' +\
 8031            'name: ' + repr(self.name) + ' ' +\
 8032            'password: ' + repr(self.password) + ' ' +\
 8033            'port: ' + repr(self.port) + ' ' +\
 8034            'port_override: ' + repr(self.port_override) + ' ' +\
 8035            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8036            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8037            'tags: ' + repr(self.tags) + ' ' +\
 8038            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8039            'username: ' + repr(self.username) + ' ' +\
 8040            '>'
 8041
 8042    def to_dict(self):
 8043        return {
 8044            'auth_database': self.auth_database,
 8045            'bind_interface': self.bind_interface,
 8046            'egress_filter': self.egress_filter,
 8047            'healthy': self.healthy,
 8048            'hostname': self.hostname,
 8049            'id': self.id,
 8050            'name': self.name,
 8051            'password': self.password,
 8052            'port': self.port,
 8053            'port_override': self.port_override,
 8054            'replica_set': self.replica_set,
 8055            'secret_store_id': self.secret_store_id,
 8056            'tags': self.tags,
 8057            'tls_required': self.tls_required,
 8058            'username': self.username,
 8059        }
 8060
 8061    @classmethod
 8062    def from_dict(cls, d):
 8063        return cls(
 8064            auth_database=d.get('auth_database'),
 8065            bind_interface=d.get('bind_interface'),
 8066            egress_filter=d.get('egress_filter'),
 8067            healthy=d.get('healthy'),
 8068            hostname=d.get('hostname'),
 8069            id=d.get('id'),
 8070            name=d.get('name'),
 8071            password=d.get('password'),
 8072            port=d.get('port'),
 8073            port_override=d.get('port_override'),
 8074            replica_set=d.get('replica_set'),
 8075            secret_store_id=d.get('secret_store_id'),
 8076            tags=d.get('tags'),
 8077            tls_required=d.get('tls_required'),
 8078            username=d.get('username'),
 8079        )
 8080
 8081
 8082class MongoLegacyReplicaset:
 8083    '''
 8084
 8085    '''
 8086    __slots__ = [
 8087        'auth_database',
 8088        'bind_interface',
 8089        'connect_to_replica',
 8090        'egress_filter',
 8091        'healthy',
 8092        'hostname',
 8093        'id',
 8094        'name',
 8095        'password',
 8096        'port',
 8097        'port_override',
 8098        'replica_set',
 8099        'secret_store_id',
 8100        'tags',
 8101        'tls_required',
 8102        'username',
 8103    ]
 8104
 8105    def __init__(
 8106        self,
 8107        auth_database=None,
 8108        bind_interface=None,
 8109        connect_to_replica=None,
 8110        egress_filter=None,
 8111        healthy=None,
 8112        hostname=None,
 8113        id=None,
 8114        name=None,
 8115        password=None,
 8116        port=None,
 8117        port_override=None,
 8118        replica_set=None,
 8119        secret_store_id=None,
 8120        tags=None,
 8121        tls_required=None,
 8122        username=None,
 8123    ):
 8124        self.auth_database = auth_database if auth_database is not None else ''
 8125        '''
 8126
 8127        '''
 8128        self.bind_interface = bind_interface if bind_interface is not None else ''
 8129        '''
 8130         Bind interface
 8131        '''
 8132        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8133        '''
 8134
 8135        '''
 8136        self.egress_filter = egress_filter if egress_filter is not None else ''
 8137        '''
 8138         A filter applied to the routing logic to pin datasource to nodes.
 8139        '''
 8140        self.healthy = healthy if healthy is not None else False
 8141        '''
 8142         True if the datasource is reachable and the credentials are valid.
 8143        '''
 8144        self.hostname = hostname if hostname is not None else ''
 8145        '''
 8146
 8147        '''
 8148        self.id = id if id is not None else ''
 8149        '''
 8150         Unique identifier of the Resource.
 8151        '''
 8152        self.name = name if name is not None else ''
 8153        '''
 8154         Unique human-readable name of the Resource.
 8155        '''
 8156        self.password = password if password is not None else ''
 8157        '''
 8158
 8159        '''
 8160        self.port = port if port is not None else 0
 8161        '''
 8162
 8163        '''
 8164        self.port_override = port_override if port_override is not None else 0
 8165        '''
 8166
 8167        '''
 8168        self.replica_set = replica_set if replica_set is not None else ''
 8169        '''
 8170
 8171        '''
 8172        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8173        '''
 8174         ID of the secret store containing credentials for this resource, if any.
 8175        '''
 8176        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8177        '''
 8178         Tags is a map of key, value pairs.
 8179        '''
 8180        self.tls_required = tls_required if tls_required is not None else False
 8181        '''
 8182
 8183        '''
 8184        self.username = username if username is not None else ''
 8185        '''
 8186
 8187        '''
 8188
 8189    def __repr__(self):
 8190        return '<sdm.MongoLegacyReplicaset ' + \
 8191            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8192            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8193            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8195            'healthy: ' + repr(self.healthy) + ' ' +\
 8196            'hostname: ' + repr(self.hostname) + ' ' +\
 8197            'id: ' + repr(self.id) + ' ' +\
 8198            'name: ' + repr(self.name) + ' ' +\
 8199            'password: ' + repr(self.password) + ' ' +\
 8200            'port: ' + repr(self.port) + ' ' +\
 8201            'port_override: ' + repr(self.port_override) + ' ' +\
 8202            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8204            'tags: ' + repr(self.tags) + ' ' +\
 8205            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8206            'username: ' + repr(self.username) + ' ' +\
 8207            '>'
 8208
 8209    def to_dict(self):
 8210        return {
 8211            'auth_database': self.auth_database,
 8212            'bind_interface': self.bind_interface,
 8213            'connect_to_replica': self.connect_to_replica,
 8214            'egress_filter': self.egress_filter,
 8215            'healthy': self.healthy,
 8216            'hostname': self.hostname,
 8217            'id': self.id,
 8218            'name': self.name,
 8219            'password': self.password,
 8220            'port': self.port,
 8221            'port_override': self.port_override,
 8222            'replica_set': self.replica_set,
 8223            'secret_store_id': self.secret_store_id,
 8224            'tags': self.tags,
 8225            'tls_required': self.tls_required,
 8226            'username': self.username,
 8227        }
 8228
 8229    @classmethod
 8230    def from_dict(cls, d):
 8231        return cls(
 8232            auth_database=d.get('auth_database'),
 8233            bind_interface=d.get('bind_interface'),
 8234            connect_to_replica=d.get('connect_to_replica'),
 8235            egress_filter=d.get('egress_filter'),
 8236            healthy=d.get('healthy'),
 8237            hostname=d.get('hostname'),
 8238            id=d.get('id'),
 8239            name=d.get('name'),
 8240            password=d.get('password'),
 8241            port=d.get('port'),
 8242            port_override=d.get('port_override'),
 8243            replica_set=d.get('replica_set'),
 8244            secret_store_id=d.get('secret_store_id'),
 8245            tags=d.get('tags'),
 8246            tls_required=d.get('tls_required'),
 8247            username=d.get('username'),
 8248        )
 8249
 8250
 8251class MongoReplicaSet:
 8252    '''
 8253
 8254    '''
 8255    __slots__ = [
 8256        'auth_database',
 8257        'bind_interface',
 8258        'connect_to_replica',
 8259        'egress_filter',
 8260        'healthy',
 8261        'hostname',
 8262        'id',
 8263        'name',
 8264        'password',
 8265        'port',
 8266        'port_override',
 8267        'replica_set',
 8268        'secret_store_id',
 8269        'tags',
 8270        'tls_required',
 8271        'username',
 8272    ]
 8273
 8274    def __init__(
 8275        self,
 8276        auth_database=None,
 8277        bind_interface=None,
 8278        connect_to_replica=None,
 8279        egress_filter=None,
 8280        healthy=None,
 8281        hostname=None,
 8282        id=None,
 8283        name=None,
 8284        password=None,
 8285        port=None,
 8286        port_override=None,
 8287        replica_set=None,
 8288        secret_store_id=None,
 8289        tags=None,
 8290        tls_required=None,
 8291        username=None,
 8292    ):
 8293        self.auth_database = auth_database if auth_database is not None else ''
 8294        '''
 8295
 8296        '''
 8297        self.bind_interface = bind_interface if bind_interface is not None else ''
 8298        '''
 8299         Bind interface
 8300        '''
 8301        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8302        '''
 8303
 8304        '''
 8305        self.egress_filter = egress_filter if egress_filter is not None else ''
 8306        '''
 8307         A filter applied to the routing logic to pin datasource to nodes.
 8308        '''
 8309        self.healthy = healthy if healthy is not None else False
 8310        '''
 8311         True if the datasource is reachable and the credentials are valid.
 8312        '''
 8313        self.hostname = hostname if hostname is not None else ''
 8314        '''
 8315
 8316        '''
 8317        self.id = id if id is not None else ''
 8318        '''
 8319         Unique identifier of the Resource.
 8320        '''
 8321        self.name = name if name is not None else ''
 8322        '''
 8323         Unique human-readable name of the Resource.
 8324        '''
 8325        self.password = password if password is not None else ''
 8326        '''
 8327
 8328        '''
 8329        self.port = port if port is not None else 0
 8330        '''
 8331
 8332        '''
 8333        self.port_override = port_override if port_override is not None else 0
 8334        '''
 8335
 8336        '''
 8337        self.replica_set = replica_set if replica_set is not None else ''
 8338        '''
 8339
 8340        '''
 8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8342        '''
 8343         ID of the secret store containing credentials for this resource, if any.
 8344        '''
 8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8346        '''
 8347         Tags is a map of key, value pairs.
 8348        '''
 8349        self.tls_required = tls_required if tls_required is not None else False
 8350        '''
 8351
 8352        '''
 8353        self.username = username if username is not None else ''
 8354        '''
 8355
 8356        '''
 8357
 8358    def __repr__(self):
 8359        return '<sdm.MongoReplicaSet ' + \
 8360            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8361            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8362            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8363            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8364            'healthy: ' + repr(self.healthy) + ' ' +\
 8365            'hostname: ' + repr(self.hostname) + ' ' +\
 8366            'id: ' + repr(self.id) + ' ' +\
 8367            'name: ' + repr(self.name) + ' ' +\
 8368            'password: ' + repr(self.password) + ' ' +\
 8369            'port: ' + repr(self.port) + ' ' +\
 8370            'port_override: ' + repr(self.port_override) + ' ' +\
 8371            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8372            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8373            'tags: ' + repr(self.tags) + ' ' +\
 8374            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8375            'username: ' + repr(self.username) + ' ' +\
 8376            '>'
 8377
 8378    def to_dict(self):
 8379        return {
 8380            'auth_database': self.auth_database,
 8381            'bind_interface': self.bind_interface,
 8382            'connect_to_replica': self.connect_to_replica,
 8383            'egress_filter': self.egress_filter,
 8384            'healthy': self.healthy,
 8385            'hostname': self.hostname,
 8386            'id': self.id,
 8387            'name': self.name,
 8388            'password': self.password,
 8389            'port': self.port,
 8390            'port_override': self.port_override,
 8391            'replica_set': self.replica_set,
 8392            'secret_store_id': self.secret_store_id,
 8393            'tags': self.tags,
 8394            'tls_required': self.tls_required,
 8395            'username': self.username,
 8396        }
 8397
 8398    @classmethod
 8399    def from_dict(cls, d):
 8400        return cls(
 8401            auth_database=d.get('auth_database'),
 8402            bind_interface=d.get('bind_interface'),
 8403            connect_to_replica=d.get('connect_to_replica'),
 8404            egress_filter=d.get('egress_filter'),
 8405            healthy=d.get('healthy'),
 8406            hostname=d.get('hostname'),
 8407            id=d.get('id'),
 8408            name=d.get('name'),
 8409            password=d.get('password'),
 8410            port=d.get('port'),
 8411            port_override=d.get('port_override'),
 8412            replica_set=d.get('replica_set'),
 8413            secret_store_id=d.get('secret_store_id'),
 8414            tags=d.get('tags'),
 8415            tls_required=d.get('tls_required'),
 8416            username=d.get('username'),
 8417        )
 8418
 8419
 8420class MongoShardedCluster:
 8421    '''
 8422
 8423    '''
 8424    __slots__ = [
 8425        'auth_database',
 8426        'bind_interface',
 8427        'egress_filter',
 8428        'healthy',
 8429        'hostname',
 8430        'id',
 8431        'name',
 8432        'password',
 8433        'port_override',
 8434        'secret_store_id',
 8435        'tags',
 8436        'tls_required',
 8437        'username',
 8438    ]
 8439
 8440    def __init__(
 8441        self,
 8442        auth_database=None,
 8443        bind_interface=None,
 8444        egress_filter=None,
 8445        healthy=None,
 8446        hostname=None,
 8447        id=None,
 8448        name=None,
 8449        password=None,
 8450        port_override=None,
 8451        secret_store_id=None,
 8452        tags=None,
 8453        tls_required=None,
 8454        username=None,
 8455    ):
 8456        self.auth_database = auth_database if auth_database is not None else ''
 8457        '''
 8458
 8459        '''
 8460        self.bind_interface = bind_interface if bind_interface is not None else ''
 8461        '''
 8462         Bind interface
 8463        '''
 8464        self.egress_filter = egress_filter if egress_filter is not None else ''
 8465        '''
 8466         A filter applied to the routing logic to pin datasource to nodes.
 8467        '''
 8468        self.healthy = healthy if healthy is not None else False
 8469        '''
 8470         True if the datasource is reachable and the credentials are valid.
 8471        '''
 8472        self.hostname = hostname if hostname is not None else ''
 8473        '''
 8474
 8475        '''
 8476        self.id = id if id is not None else ''
 8477        '''
 8478         Unique identifier of the Resource.
 8479        '''
 8480        self.name = name if name is not None else ''
 8481        '''
 8482         Unique human-readable name of the Resource.
 8483        '''
 8484        self.password = password if password is not None else ''
 8485        '''
 8486
 8487        '''
 8488        self.port_override = port_override if port_override is not None else 0
 8489        '''
 8490
 8491        '''
 8492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8493        '''
 8494         ID of the secret store containing credentials for this resource, if any.
 8495        '''
 8496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8497        '''
 8498         Tags is a map of key, value pairs.
 8499        '''
 8500        self.tls_required = tls_required if tls_required is not None else False
 8501        '''
 8502
 8503        '''
 8504        self.username = username if username is not None else ''
 8505        '''
 8506
 8507        '''
 8508
 8509    def __repr__(self):
 8510        return '<sdm.MongoShardedCluster ' + \
 8511            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8512            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8513            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8514            'healthy: ' + repr(self.healthy) + ' ' +\
 8515            'hostname: ' + repr(self.hostname) + ' ' +\
 8516            'id: ' + repr(self.id) + ' ' +\
 8517            'name: ' + repr(self.name) + ' ' +\
 8518            'password: ' + repr(self.password) + ' ' +\
 8519            'port_override: ' + repr(self.port_override) + ' ' +\
 8520            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8521            'tags: ' + repr(self.tags) + ' ' +\
 8522            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8523            'username: ' + repr(self.username) + ' ' +\
 8524            '>'
 8525
 8526    def to_dict(self):
 8527        return {
 8528            'auth_database': self.auth_database,
 8529            'bind_interface': self.bind_interface,
 8530            'egress_filter': self.egress_filter,
 8531            'healthy': self.healthy,
 8532            'hostname': self.hostname,
 8533            'id': self.id,
 8534            'name': self.name,
 8535            'password': self.password,
 8536            'port_override': self.port_override,
 8537            'secret_store_id': self.secret_store_id,
 8538            'tags': self.tags,
 8539            'tls_required': self.tls_required,
 8540            'username': self.username,
 8541        }
 8542
 8543    @classmethod
 8544    def from_dict(cls, d):
 8545        return cls(
 8546            auth_database=d.get('auth_database'),
 8547            bind_interface=d.get('bind_interface'),
 8548            egress_filter=d.get('egress_filter'),
 8549            healthy=d.get('healthy'),
 8550            hostname=d.get('hostname'),
 8551            id=d.get('id'),
 8552            name=d.get('name'),
 8553            password=d.get('password'),
 8554            port_override=d.get('port_override'),
 8555            secret_store_id=d.get('secret_store_id'),
 8556            tags=d.get('tags'),
 8557            tls_required=d.get('tls_required'),
 8558            username=d.get('username'),
 8559        )
 8560
 8561
 8562class Mysql:
 8563    '''
 8564
 8565    '''
 8566    __slots__ = [
 8567        'bind_interface',
 8568        'database',
 8569        'egress_filter',
 8570        'healthy',
 8571        'hostname',
 8572        'id',
 8573        'name',
 8574        'password',
 8575        'port',
 8576        'port_override',
 8577        'secret_store_id',
 8578        'tags',
 8579        'username',
 8580    ]
 8581
 8582    def __init__(
 8583        self,
 8584        bind_interface=None,
 8585        database=None,
 8586        egress_filter=None,
 8587        healthy=None,
 8588        hostname=None,
 8589        id=None,
 8590        name=None,
 8591        password=None,
 8592        port=None,
 8593        port_override=None,
 8594        secret_store_id=None,
 8595        tags=None,
 8596        username=None,
 8597    ):
 8598        self.bind_interface = bind_interface if bind_interface is not None else ''
 8599        '''
 8600         Bind interface
 8601        '''
 8602        self.database = database if database is not None else ''
 8603        '''
 8604
 8605        '''
 8606        self.egress_filter = egress_filter if egress_filter is not None else ''
 8607        '''
 8608         A filter applied to the routing logic to pin datasource to nodes.
 8609        '''
 8610        self.healthy = healthy if healthy is not None else False
 8611        '''
 8612         True if the datasource is reachable and the credentials are valid.
 8613        '''
 8614        self.hostname = hostname if hostname is not None else ''
 8615        '''
 8616
 8617        '''
 8618        self.id = id if id is not None else ''
 8619        '''
 8620         Unique identifier of the Resource.
 8621        '''
 8622        self.name = name if name is not None else ''
 8623        '''
 8624         Unique human-readable name of the Resource.
 8625        '''
 8626        self.password = password if password is not None else ''
 8627        '''
 8628
 8629        '''
 8630        self.port = port if port is not None else 0
 8631        '''
 8632
 8633        '''
 8634        self.port_override = port_override if port_override is not None else 0
 8635        '''
 8636
 8637        '''
 8638        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8639        '''
 8640         ID of the secret store containing credentials for this resource, if any.
 8641        '''
 8642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8643        '''
 8644         Tags is a map of key, value pairs.
 8645        '''
 8646        self.username = username if username is not None else ''
 8647        '''
 8648
 8649        '''
 8650
 8651    def __repr__(self):
 8652        return '<sdm.Mysql ' + \
 8653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8654            'database: ' + repr(self.database) + ' ' +\
 8655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8656            'healthy: ' + repr(self.healthy) + ' ' +\
 8657            'hostname: ' + repr(self.hostname) + ' ' +\
 8658            'id: ' + repr(self.id) + ' ' +\
 8659            'name: ' + repr(self.name) + ' ' +\
 8660            'password: ' + repr(self.password) + ' ' +\
 8661            'port: ' + repr(self.port) + ' ' +\
 8662            'port_override: ' + repr(self.port_override) + ' ' +\
 8663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8664            'tags: ' + repr(self.tags) + ' ' +\
 8665            'username: ' + repr(self.username) + ' ' +\
 8666            '>'
 8667
 8668    def to_dict(self):
 8669        return {
 8670            'bind_interface': self.bind_interface,
 8671            'database': self.database,
 8672            'egress_filter': self.egress_filter,
 8673            'healthy': self.healthy,
 8674            'hostname': self.hostname,
 8675            'id': self.id,
 8676            'name': self.name,
 8677            'password': self.password,
 8678            'port': self.port,
 8679            'port_override': self.port_override,
 8680            'secret_store_id': self.secret_store_id,
 8681            'tags': self.tags,
 8682            'username': self.username,
 8683        }
 8684
 8685    @classmethod
 8686    def from_dict(cls, d):
 8687        return cls(
 8688            bind_interface=d.get('bind_interface'),
 8689            database=d.get('database'),
 8690            egress_filter=d.get('egress_filter'),
 8691            healthy=d.get('healthy'),
 8692            hostname=d.get('hostname'),
 8693            id=d.get('id'),
 8694            name=d.get('name'),
 8695            password=d.get('password'),
 8696            port=d.get('port'),
 8697            port_override=d.get('port_override'),
 8698            secret_store_id=d.get('secret_store_id'),
 8699            tags=d.get('tags'),
 8700            username=d.get('username'),
 8701        )
 8702
 8703
 8704class Neptune:
 8705    '''
 8706
 8707    '''
 8708    __slots__ = [
 8709        'bind_interface',
 8710        'egress_filter',
 8711        'endpoint',
 8712        'healthy',
 8713        'id',
 8714        'name',
 8715        'port',
 8716        'port_override',
 8717        'secret_store_id',
 8718        'tags',
 8719    ]
 8720
 8721    def __init__(
 8722        self,
 8723        bind_interface=None,
 8724        egress_filter=None,
 8725        endpoint=None,
 8726        healthy=None,
 8727        id=None,
 8728        name=None,
 8729        port=None,
 8730        port_override=None,
 8731        secret_store_id=None,
 8732        tags=None,
 8733    ):
 8734        self.bind_interface = bind_interface if bind_interface is not None else ''
 8735        '''
 8736         Bind interface
 8737        '''
 8738        self.egress_filter = egress_filter if egress_filter is not None else ''
 8739        '''
 8740         A filter applied to the routing logic to pin datasource to nodes.
 8741        '''
 8742        self.endpoint = endpoint if endpoint is not None else ''
 8743        '''
 8744
 8745        '''
 8746        self.healthy = healthy if healthy is not None else False
 8747        '''
 8748         True if the datasource is reachable and the credentials are valid.
 8749        '''
 8750        self.id = id if id is not None else ''
 8751        '''
 8752         Unique identifier of the Resource.
 8753        '''
 8754        self.name = name if name is not None else ''
 8755        '''
 8756         Unique human-readable name of the Resource.
 8757        '''
 8758        self.port = port if port is not None else 0
 8759        '''
 8760
 8761        '''
 8762        self.port_override = port_override if port_override is not None else 0
 8763        '''
 8764
 8765        '''
 8766        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8767        '''
 8768         ID of the secret store containing credentials for this resource, if any.
 8769        '''
 8770        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8771        '''
 8772         Tags is a map of key, value pairs.
 8773        '''
 8774
 8775    def __repr__(self):
 8776        return '<sdm.Neptune ' + \
 8777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8779            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8780            'healthy: ' + repr(self.healthy) + ' ' +\
 8781            'id: ' + repr(self.id) + ' ' +\
 8782            'name: ' + repr(self.name) + ' ' +\
 8783            'port: ' + repr(self.port) + ' ' +\
 8784            'port_override: ' + repr(self.port_override) + ' ' +\
 8785            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8786            'tags: ' + repr(self.tags) + ' ' +\
 8787            '>'
 8788
 8789    def to_dict(self):
 8790        return {
 8791            'bind_interface': self.bind_interface,
 8792            'egress_filter': self.egress_filter,
 8793            'endpoint': self.endpoint,
 8794            'healthy': self.healthy,
 8795            'id': self.id,
 8796            'name': self.name,
 8797            'port': self.port,
 8798            'port_override': self.port_override,
 8799            'secret_store_id': self.secret_store_id,
 8800            'tags': self.tags,
 8801        }
 8802
 8803    @classmethod
 8804    def from_dict(cls, d):
 8805        return cls(
 8806            bind_interface=d.get('bind_interface'),
 8807            egress_filter=d.get('egress_filter'),
 8808            endpoint=d.get('endpoint'),
 8809            healthy=d.get('healthy'),
 8810            id=d.get('id'),
 8811            name=d.get('name'),
 8812            port=d.get('port'),
 8813            port_override=d.get('port_override'),
 8814            secret_store_id=d.get('secret_store_id'),
 8815            tags=d.get('tags'),
 8816        )
 8817
 8818
 8819class NeptuneIAM:
 8820    '''
 8821
 8822    '''
 8823    __slots__ = [
 8824        'access_key',
 8825        'bind_interface',
 8826        'egress_filter',
 8827        'endpoint',
 8828        'healthy',
 8829        'id',
 8830        'name',
 8831        'port',
 8832        'port_override',
 8833        'region',
 8834        'role_arn',
 8835        'role_external_id',
 8836        'secret_access_key',
 8837        'secret_store_id',
 8838        'tags',
 8839    ]
 8840
 8841    def __init__(
 8842        self,
 8843        access_key=None,
 8844        bind_interface=None,
 8845        egress_filter=None,
 8846        endpoint=None,
 8847        healthy=None,
 8848        id=None,
 8849        name=None,
 8850        port=None,
 8851        port_override=None,
 8852        region=None,
 8853        role_arn=None,
 8854        role_external_id=None,
 8855        secret_access_key=None,
 8856        secret_store_id=None,
 8857        tags=None,
 8858    ):
 8859        self.access_key = access_key if access_key is not None else ''
 8860        '''
 8861
 8862        '''
 8863        self.bind_interface = bind_interface if bind_interface is not None else ''
 8864        '''
 8865         Bind interface
 8866        '''
 8867        self.egress_filter = egress_filter if egress_filter is not None else ''
 8868        '''
 8869         A filter applied to the routing logic to pin datasource to nodes.
 8870        '''
 8871        self.endpoint = endpoint if endpoint is not None else ''
 8872        '''
 8873
 8874        '''
 8875        self.healthy = healthy if healthy is not None else False
 8876        '''
 8877         True if the datasource is reachable and the credentials are valid.
 8878        '''
 8879        self.id = id if id is not None else ''
 8880        '''
 8881         Unique identifier of the Resource.
 8882        '''
 8883        self.name = name if name is not None else ''
 8884        '''
 8885         Unique human-readable name of the Resource.
 8886        '''
 8887        self.port = port if port is not None else 0
 8888        '''
 8889
 8890        '''
 8891        self.port_override = port_override if port_override is not None else 0
 8892        '''
 8893
 8894        '''
 8895        self.region = region if region is not None else ''
 8896        '''
 8897
 8898        '''
 8899        self.role_arn = role_arn if role_arn is not None else ''
 8900        '''
 8901
 8902        '''
 8903        self.role_external_id = role_external_id if role_external_id is not None else ''
 8904        '''
 8905
 8906        '''
 8907        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8908        '''
 8909
 8910        '''
 8911        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8912        '''
 8913         ID of the secret store containing credentials for this resource, if any.
 8914        '''
 8915        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8916        '''
 8917         Tags is a map of key, value pairs.
 8918        '''
 8919
 8920    def __repr__(self):
 8921        return '<sdm.NeptuneIAM ' + \
 8922            'access_key: ' + repr(self.access_key) + ' ' +\
 8923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8924            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8925            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8926            'healthy: ' + repr(self.healthy) + ' ' +\
 8927            'id: ' + repr(self.id) + ' ' +\
 8928            'name: ' + repr(self.name) + ' ' +\
 8929            'port: ' + repr(self.port) + ' ' +\
 8930            'port_override: ' + repr(self.port_override) + ' ' +\
 8931            'region: ' + repr(self.region) + ' ' +\
 8932            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8933            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8934            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8935            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8936            'tags: ' + repr(self.tags) + ' ' +\
 8937            '>'
 8938
 8939    def to_dict(self):
 8940        return {
 8941            'access_key': self.access_key,
 8942            'bind_interface': self.bind_interface,
 8943            'egress_filter': self.egress_filter,
 8944            'endpoint': self.endpoint,
 8945            'healthy': self.healthy,
 8946            'id': self.id,
 8947            'name': self.name,
 8948            'port': self.port,
 8949            'port_override': self.port_override,
 8950            'region': self.region,
 8951            'role_arn': self.role_arn,
 8952            'role_external_id': self.role_external_id,
 8953            'secret_access_key': self.secret_access_key,
 8954            'secret_store_id': self.secret_store_id,
 8955            'tags': self.tags,
 8956        }
 8957
 8958    @classmethod
 8959    def from_dict(cls, d):
 8960        return cls(
 8961            access_key=d.get('access_key'),
 8962            bind_interface=d.get('bind_interface'),
 8963            egress_filter=d.get('egress_filter'),
 8964            endpoint=d.get('endpoint'),
 8965            healthy=d.get('healthy'),
 8966            id=d.get('id'),
 8967            name=d.get('name'),
 8968            port=d.get('port'),
 8969            port_override=d.get('port_override'),
 8970            region=d.get('region'),
 8971            role_arn=d.get('role_arn'),
 8972            role_external_id=d.get('role_external_id'),
 8973            secret_access_key=d.get('secret_access_key'),
 8974            secret_store_id=d.get('secret_store_id'),
 8975            tags=d.get('tags'),
 8976        )
 8977
 8978
 8979class NodeCreateResponse:
 8980    '''
 8981     NodeCreateResponse reports how the Nodes were created in the system.
 8982    '''
 8983    __slots__ = [
 8984        'meta',
 8985        'node',
 8986        'rate_limit',
 8987        'token',
 8988    ]
 8989
 8990    def __init__(
 8991        self,
 8992        meta=None,
 8993        node=None,
 8994        rate_limit=None,
 8995        token=None,
 8996    ):
 8997        self.meta = meta if meta is not None else None
 8998        '''
 8999         Reserved for future use.
 9000        '''
 9001        self.node = node if node is not None else None
 9002        '''
 9003         The created Node.
 9004        '''
 9005        self.rate_limit = rate_limit if rate_limit is not None else None
 9006        '''
 9007         Rate limit information.
 9008        '''
 9009        self.token = token if token is not None else ''
 9010        '''
 9011         The auth token generated for the Node. The Node will use this token to
 9012         authenticate with the strongDM API.
 9013        '''
 9014
 9015    def __repr__(self):
 9016        return '<sdm.NodeCreateResponse ' + \
 9017            'meta: ' + repr(self.meta) + ' ' +\
 9018            'node: ' + repr(self.node) + ' ' +\
 9019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9020            'token: ' + repr(self.token) + ' ' +\
 9021            '>'
 9022
 9023    def to_dict(self):
 9024        return {
 9025            'meta': self.meta,
 9026            'node': self.node,
 9027            'rate_limit': self.rate_limit,
 9028            'token': self.token,
 9029        }
 9030
 9031    @classmethod
 9032    def from_dict(cls, d):
 9033        return cls(
 9034            meta=d.get('meta'),
 9035            node=d.get('node'),
 9036            rate_limit=d.get('rate_limit'),
 9037            token=d.get('token'),
 9038        )
 9039
 9040
 9041class NodeDeleteResponse:
 9042    '''
 9043     NodeDeleteResponse returns information about a Node that was deleted.
 9044    '''
 9045    __slots__ = [
 9046        'meta',
 9047        'rate_limit',
 9048    ]
 9049
 9050    def __init__(
 9051        self,
 9052        meta=None,
 9053        rate_limit=None,
 9054    ):
 9055        self.meta = meta if meta is not None else None
 9056        '''
 9057         Reserved for future use.
 9058        '''
 9059        self.rate_limit = rate_limit if rate_limit is not None else None
 9060        '''
 9061         Rate limit information.
 9062        '''
 9063
 9064    def __repr__(self):
 9065        return '<sdm.NodeDeleteResponse ' + \
 9066            'meta: ' + repr(self.meta) + ' ' +\
 9067            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9068            '>'
 9069
 9070    def to_dict(self):
 9071        return {
 9072            'meta': self.meta,
 9073            'rate_limit': self.rate_limit,
 9074        }
 9075
 9076    @classmethod
 9077    def from_dict(cls, d):
 9078        return cls(
 9079            meta=d.get('meta'),
 9080            rate_limit=d.get('rate_limit'),
 9081        )
 9082
 9083
 9084class NodeGetResponse:
 9085    '''
 9086     NodeGetResponse returns a requested Node.
 9087    '''
 9088    __slots__ = [
 9089        'meta',
 9090        'node',
 9091        'rate_limit',
 9092    ]
 9093
 9094    def __init__(
 9095        self,
 9096        meta=None,
 9097        node=None,
 9098        rate_limit=None,
 9099    ):
 9100        self.meta = meta if meta is not None else None
 9101        '''
 9102         Reserved for future use.
 9103        '''
 9104        self.node = node if node is not None else None
 9105        '''
 9106         The requested Node.
 9107        '''
 9108        self.rate_limit = rate_limit if rate_limit is not None else None
 9109        '''
 9110         Rate limit information.
 9111        '''
 9112
 9113    def __repr__(self):
 9114        return '<sdm.NodeGetResponse ' + \
 9115            'meta: ' + repr(self.meta) + ' ' +\
 9116            'node: ' + repr(self.node) + ' ' +\
 9117            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9118            '>'
 9119
 9120    def to_dict(self):
 9121        return {
 9122            'meta': self.meta,
 9123            'node': self.node,
 9124            'rate_limit': self.rate_limit,
 9125        }
 9126
 9127    @classmethod
 9128    def from_dict(cls, d):
 9129        return cls(
 9130            meta=d.get('meta'),
 9131            node=d.get('node'),
 9132            rate_limit=d.get('rate_limit'),
 9133        )
 9134
 9135
 9136class NodeUpdateResponse:
 9137    '''
 9138     NodeUpdateResponse returns the fields of a Node after it has been updated by
 9139     a NodeUpdateRequest.
 9140    '''
 9141    __slots__ = [
 9142        'meta',
 9143        'node',
 9144        'rate_limit',
 9145    ]
 9146
 9147    def __init__(
 9148        self,
 9149        meta=None,
 9150        node=None,
 9151        rate_limit=None,
 9152    ):
 9153        self.meta = meta if meta is not None else None
 9154        '''
 9155         Reserved for future use.
 9156        '''
 9157        self.node = node if node is not None else None
 9158        '''
 9159         The updated Node.
 9160        '''
 9161        self.rate_limit = rate_limit if rate_limit is not None else None
 9162        '''
 9163         Rate limit information.
 9164        '''
 9165
 9166    def __repr__(self):
 9167        return '<sdm.NodeUpdateResponse ' + \
 9168            'meta: ' + repr(self.meta) + ' ' +\
 9169            'node: ' + repr(self.node) + ' ' +\
 9170            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9171            '>'
 9172
 9173    def to_dict(self):
 9174        return {
 9175            'meta': self.meta,
 9176            'node': self.node,
 9177            'rate_limit': self.rate_limit,
 9178        }
 9179
 9180    @classmethod
 9181    def from_dict(cls, d):
 9182        return cls(
 9183            meta=d.get('meta'),
 9184            node=d.get('node'),
 9185            rate_limit=d.get('rate_limit'),
 9186        )
 9187
 9188
 9189class Oracle:
 9190    '''
 9191
 9192    '''
 9193    __slots__ = [
 9194        'bind_interface',
 9195        'database',
 9196        'egress_filter',
 9197        'healthy',
 9198        'hostname',
 9199        'id',
 9200        'name',
 9201        'password',
 9202        'port',
 9203        'port_override',
 9204        'secret_store_id',
 9205        'tags',
 9206        'tls_required',
 9207        'username',
 9208    ]
 9209
 9210    def __init__(
 9211        self,
 9212        bind_interface=None,
 9213        database=None,
 9214        egress_filter=None,
 9215        healthy=None,
 9216        hostname=None,
 9217        id=None,
 9218        name=None,
 9219        password=None,
 9220        port=None,
 9221        port_override=None,
 9222        secret_store_id=None,
 9223        tags=None,
 9224        tls_required=None,
 9225        username=None,
 9226    ):
 9227        self.bind_interface = bind_interface if bind_interface is not None else ''
 9228        '''
 9229         Bind interface
 9230        '''
 9231        self.database = database if database is not None else ''
 9232        '''
 9233
 9234        '''
 9235        self.egress_filter = egress_filter if egress_filter is not None else ''
 9236        '''
 9237         A filter applied to the routing logic to pin datasource to nodes.
 9238        '''
 9239        self.healthy = healthy if healthy is not None else False
 9240        '''
 9241         True if the datasource is reachable and the credentials are valid.
 9242        '''
 9243        self.hostname = hostname if hostname is not None else ''
 9244        '''
 9245
 9246        '''
 9247        self.id = id if id is not None else ''
 9248        '''
 9249         Unique identifier of the Resource.
 9250        '''
 9251        self.name = name if name is not None else ''
 9252        '''
 9253         Unique human-readable name of the Resource.
 9254        '''
 9255        self.password = password if password is not None else ''
 9256        '''
 9257
 9258        '''
 9259        self.port = port if port is not None else 0
 9260        '''
 9261
 9262        '''
 9263        self.port_override = port_override if port_override is not None else 0
 9264        '''
 9265
 9266        '''
 9267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9268        '''
 9269         ID of the secret store containing credentials for this resource, if any.
 9270        '''
 9271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9272        '''
 9273         Tags is a map of key, value pairs.
 9274        '''
 9275        self.tls_required = tls_required if tls_required is not None else False
 9276        '''
 9277
 9278        '''
 9279        self.username = username if username is not None else ''
 9280        '''
 9281
 9282        '''
 9283
 9284    def __repr__(self):
 9285        return '<sdm.Oracle ' + \
 9286            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9287            'database: ' + repr(self.database) + ' ' +\
 9288            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9289            'healthy: ' + repr(self.healthy) + ' ' +\
 9290            'hostname: ' + repr(self.hostname) + ' ' +\
 9291            'id: ' + repr(self.id) + ' ' +\
 9292            'name: ' + repr(self.name) + ' ' +\
 9293            'password: ' + repr(self.password) + ' ' +\
 9294            'port: ' + repr(self.port) + ' ' +\
 9295            'port_override: ' + repr(self.port_override) + ' ' +\
 9296            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9297            'tags: ' + repr(self.tags) + ' ' +\
 9298            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9299            'username: ' + repr(self.username) + ' ' +\
 9300            '>'
 9301
 9302    def to_dict(self):
 9303        return {
 9304            'bind_interface': self.bind_interface,
 9305            'database': self.database,
 9306            'egress_filter': self.egress_filter,
 9307            'healthy': self.healthy,
 9308            'hostname': self.hostname,
 9309            'id': self.id,
 9310            'name': self.name,
 9311            'password': self.password,
 9312            'port': self.port,
 9313            'port_override': self.port_override,
 9314            'secret_store_id': self.secret_store_id,
 9315            'tags': self.tags,
 9316            'tls_required': self.tls_required,
 9317            'username': self.username,
 9318        }
 9319
 9320    @classmethod
 9321    def from_dict(cls, d):
 9322        return cls(
 9323            bind_interface=d.get('bind_interface'),
 9324            database=d.get('database'),
 9325            egress_filter=d.get('egress_filter'),
 9326            healthy=d.get('healthy'),
 9327            hostname=d.get('hostname'),
 9328            id=d.get('id'),
 9329            name=d.get('name'),
 9330            password=d.get('password'),
 9331            port=d.get('port'),
 9332            port_override=d.get('port_override'),
 9333            secret_store_id=d.get('secret_store_id'),
 9334            tags=d.get('tags'),
 9335            tls_required=d.get('tls_required'),
 9336            username=d.get('username'),
 9337        )
 9338
 9339
 9340class Postgres:
 9341    '''
 9342
 9343    '''
 9344    __slots__ = [
 9345        'bind_interface',
 9346        'database',
 9347        'egress_filter',
 9348        'healthy',
 9349        'hostname',
 9350        'id',
 9351        'name',
 9352        'override_database',
 9353        'password',
 9354        'port',
 9355        'port_override',
 9356        'secret_store_id',
 9357        'tags',
 9358        'username',
 9359    ]
 9360
 9361    def __init__(
 9362        self,
 9363        bind_interface=None,
 9364        database=None,
 9365        egress_filter=None,
 9366        healthy=None,
 9367        hostname=None,
 9368        id=None,
 9369        name=None,
 9370        override_database=None,
 9371        password=None,
 9372        port=None,
 9373        port_override=None,
 9374        secret_store_id=None,
 9375        tags=None,
 9376        username=None,
 9377    ):
 9378        self.bind_interface = bind_interface if bind_interface is not None else ''
 9379        '''
 9380         Bind interface
 9381        '''
 9382        self.database = database if database is not None else ''
 9383        '''
 9384
 9385        '''
 9386        self.egress_filter = egress_filter if egress_filter is not None else ''
 9387        '''
 9388         A filter applied to the routing logic to pin datasource to nodes.
 9389        '''
 9390        self.healthy = healthy if healthy is not None else False
 9391        '''
 9392         True if the datasource is reachable and the credentials are valid.
 9393        '''
 9394        self.hostname = hostname if hostname is not None else ''
 9395        '''
 9396
 9397        '''
 9398        self.id = id if id is not None else ''
 9399        '''
 9400         Unique identifier of the Resource.
 9401        '''
 9402        self.name = name if name is not None else ''
 9403        '''
 9404         Unique human-readable name of the Resource.
 9405        '''
 9406        self.override_database = override_database if override_database is not None else False
 9407        '''
 9408
 9409        '''
 9410        self.password = password if password is not None else ''
 9411        '''
 9412
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        '''
 9416
 9417        '''
 9418        self.port_override = port_override if port_override is not None else 0
 9419        '''
 9420
 9421        '''
 9422        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9423        '''
 9424         ID of the secret store containing credentials for this resource, if any.
 9425        '''
 9426        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9427        '''
 9428         Tags is a map of key, value pairs.
 9429        '''
 9430        self.username = username if username is not None else ''
 9431        '''
 9432
 9433        '''
 9434
 9435    def __repr__(self):
 9436        return '<sdm.Postgres ' + \
 9437            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9438            'database: ' + repr(self.database) + ' ' +\
 9439            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9440            'healthy: ' + repr(self.healthy) + ' ' +\
 9441            'hostname: ' + repr(self.hostname) + ' ' +\
 9442            'id: ' + repr(self.id) + ' ' +\
 9443            'name: ' + repr(self.name) + ' ' +\
 9444            'override_database: ' + repr(self.override_database) + ' ' +\
 9445            'password: ' + repr(self.password) + ' ' +\
 9446            'port: ' + repr(self.port) + ' ' +\
 9447            'port_override: ' + repr(self.port_override) + ' ' +\
 9448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9449            'tags: ' + repr(self.tags) + ' ' +\
 9450            'username: ' + repr(self.username) + ' ' +\
 9451            '>'
 9452
 9453    def to_dict(self):
 9454        return {
 9455            'bind_interface': self.bind_interface,
 9456            'database': self.database,
 9457            'egress_filter': self.egress_filter,
 9458            'healthy': self.healthy,
 9459            'hostname': self.hostname,
 9460            'id': self.id,
 9461            'name': self.name,
 9462            'override_database': self.override_database,
 9463            'password': self.password,
 9464            'port': self.port,
 9465            'port_override': self.port_override,
 9466            'secret_store_id': self.secret_store_id,
 9467            'tags': self.tags,
 9468            'username': self.username,
 9469        }
 9470
 9471    @classmethod
 9472    def from_dict(cls, d):
 9473        return cls(
 9474            bind_interface=d.get('bind_interface'),
 9475            database=d.get('database'),
 9476            egress_filter=d.get('egress_filter'),
 9477            healthy=d.get('healthy'),
 9478            hostname=d.get('hostname'),
 9479            id=d.get('id'),
 9480            name=d.get('name'),
 9481            override_database=d.get('override_database'),
 9482            password=d.get('password'),
 9483            port=d.get('port'),
 9484            port_override=d.get('port_override'),
 9485            secret_store_id=d.get('secret_store_id'),
 9486            tags=d.get('tags'),
 9487            username=d.get('username'),
 9488        )
 9489
 9490
 9491class Presto:
 9492    '''
 9493
 9494    '''
 9495    __slots__ = [
 9496        'bind_interface',
 9497        'database',
 9498        'egress_filter',
 9499        'healthy',
 9500        'hostname',
 9501        'id',
 9502        'name',
 9503        'password',
 9504        'port',
 9505        'port_override',
 9506        'secret_store_id',
 9507        'tags',
 9508        'tls_required',
 9509        'username',
 9510    ]
 9511
 9512    def __init__(
 9513        self,
 9514        bind_interface=None,
 9515        database=None,
 9516        egress_filter=None,
 9517        healthy=None,
 9518        hostname=None,
 9519        id=None,
 9520        name=None,
 9521        password=None,
 9522        port=None,
 9523        port_override=None,
 9524        secret_store_id=None,
 9525        tags=None,
 9526        tls_required=None,
 9527        username=None,
 9528    ):
 9529        self.bind_interface = bind_interface if bind_interface is not None else ''
 9530        '''
 9531         Bind interface
 9532        '''
 9533        self.database = database if database is not None else ''
 9534        '''
 9535
 9536        '''
 9537        self.egress_filter = egress_filter if egress_filter is not None else ''
 9538        '''
 9539         A filter applied to the routing logic to pin datasource to nodes.
 9540        '''
 9541        self.healthy = healthy if healthy is not None else False
 9542        '''
 9543         True if the datasource is reachable and the credentials are valid.
 9544        '''
 9545        self.hostname = hostname if hostname is not None else ''
 9546        '''
 9547
 9548        '''
 9549        self.id = id if id is not None else ''
 9550        '''
 9551         Unique identifier of the Resource.
 9552        '''
 9553        self.name = name if name is not None else ''
 9554        '''
 9555         Unique human-readable name of the Resource.
 9556        '''
 9557        self.password = password if password is not None else ''
 9558        '''
 9559
 9560        '''
 9561        self.port = port if port is not None else 0
 9562        '''
 9563
 9564        '''
 9565        self.port_override = port_override if port_override is not None else 0
 9566        '''
 9567
 9568        '''
 9569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9570        '''
 9571         ID of the secret store containing credentials for this resource, if any.
 9572        '''
 9573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9574        '''
 9575         Tags is a map of key, value pairs.
 9576        '''
 9577        self.tls_required = tls_required if tls_required is not None else False
 9578        '''
 9579
 9580        '''
 9581        self.username = username if username is not None else ''
 9582        '''
 9583
 9584        '''
 9585
 9586    def __repr__(self):
 9587        return '<sdm.Presto ' + \
 9588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9589            'database: ' + repr(self.database) + ' ' +\
 9590            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9591            'healthy: ' + repr(self.healthy) + ' ' +\
 9592            'hostname: ' + repr(self.hostname) + ' ' +\
 9593            'id: ' + repr(self.id) + ' ' +\
 9594            'name: ' + repr(self.name) + ' ' +\
 9595            'password: ' + repr(self.password) + ' ' +\
 9596            'port: ' + repr(self.port) + ' ' +\
 9597            'port_override: ' + repr(self.port_override) + ' ' +\
 9598            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9599            'tags: ' + repr(self.tags) + ' ' +\
 9600            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9601            'username: ' + repr(self.username) + ' ' +\
 9602            '>'
 9603
 9604    def to_dict(self):
 9605        return {
 9606            'bind_interface': self.bind_interface,
 9607            'database': self.database,
 9608            'egress_filter': self.egress_filter,
 9609            'healthy': self.healthy,
 9610            'hostname': self.hostname,
 9611            'id': self.id,
 9612            'name': self.name,
 9613            'password': self.password,
 9614            'port': self.port,
 9615            'port_override': self.port_override,
 9616            'secret_store_id': self.secret_store_id,
 9617            'tags': self.tags,
 9618            'tls_required': self.tls_required,
 9619            'username': self.username,
 9620        }
 9621
 9622    @classmethod
 9623    def from_dict(cls, d):
 9624        return cls(
 9625            bind_interface=d.get('bind_interface'),
 9626            database=d.get('database'),
 9627            egress_filter=d.get('egress_filter'),
 9628            healthy=d.get('healthy'),
 9629            hostname=d.get('hostname'),
 9630            id=d.get('id'),
 9631            name=d.get('name'),
 9632            password=d.get('password'),
 9633            port=d.get('port'),
 9634            port_override=d.get('port_override'),
 9635            secret_store_id=d.get('secret_store_id'),
 9636            tags=d.get('tags'),
 9637            tls_required=d.get('tls_required'),
 9638            username=d.get('username'),
 9639        )
 9640
 9641
 9642class RDP:
 9643    '''
 9644
 9645    '''
 9646    __slots__ = [
 9647        'bind_interface',
 9648        'downgrade_nla_connections',
 9649        'egress_filter',
 9650        'healthy',
 9651        'hostname',
 9652        'id',
 9653        'name',
 9654        'password',
 9655        'port',
 9656        'port_override',
 9657        'secret_store_id',
 9658        'tags',
 9659        'username',
 9660    ]
 9661
 9662    def __init__(
 9663        self,
 9664        bind_interface=None,
 9665        downgrade_nla_connections=None,
 9666        egress_filter=None,
 9667        healthy=None,
 9668        hostname=None,
 9669        id=None,
 9670        name=None,
 9671        password=None,
 9672        port=None,
 9673        port_override=None,
 9674        secret_store_id=None,
 9675        tags=None,
 9676        username=None,
 9677    ):
 9678        self.bind_interface = bind_interface if bind_interface is not None else ''
 9679        '''
 9680         Bind interface
 9681        '''
 9682        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9683        '''
 9684
 9685        '''
 9686        self.egress_filter = egress_filter if egress_filter is not None else ''
 9687        '''
 9688         A filter applied to the routing logic to pin datasource to nodes.
 9689        '''
 9690        self.healthy = healthy if healthy is not None else False
 9691        '''
 9692         True if the datasource is reachable and the credentials are valid.
 9693        '''
 9694        self.hostname = hostname if hostname is not None else ''
 9695        '''
 9696
 9697        '''
 9698        self.id = id if id is not None else ''
 9699        '''
 9700         Unique identifier of the Resource.
 9701        '''
 9702        self.name = name if name is not None else ''
 9703        '''
 9704         Unique human-readable name of the Resource.
 9705        '''
 9706        self.password = password if password is not None else ''
 9707        '''
 9708
 9709        '''
 9710        self.port = port if port is not None else 0
 9711        '''
 9712
 9713        '''
 9714        self.port_override = port_override if port_override is not None else 0
 9715        '''
 9716
 9717        '''
 9718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9719        '''
 9720         ID of the secret store containing credentials for this resource, if any.
 9721        '''
 9722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9723        '''
 9724         Tags is a map of key, value pairs.
 9725        '''
 9726        self.username = username if username is not None else ''
 9727        '''
 9728
 9729        '''
 9730
 9731    def __repr__(self):
 9732        return '<sdm.RDP ' + \
 9733            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9734            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9735            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9736            'healthy: ' + repr(self.healthy) + ' ' +\
 9737            'hostname: ' + repr(self.hostname) + ' ' +\
 9738            'id: ' + repr(self.id) + ' ' +\
 9739            'name: ' + repr(self.name) + ' ' +\
 9740            'password: ' + repr(self.password) + ' ' +\
 9741            'port: ' + repr(self.port) + ' ' +\
 9742            'port_override: ' + repr(self.port_override) + ' ' +\
 9743            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9744            'tags: ' + repr(self.tags) + ' ' +\
 9745            'username: ' + repr(self.username) + ' ' +\
 9746            '>'
 9747
 9748    def to_dict(self):
 9749        return {
 9750            'bind_interface': self.bind_interface,
 9751            'downgrade_nla_connections': self.downgrade_nla_connections,
 9752            'egress_filter': self.egress_filter,
 9753            'healthy': self.healthy,
 9754            'hostname': self.hostname,
 9755            'id': self.id,
 9756            'name': self.name,
 9757            'password': self.password,
 9758            'port': self.port,
 9759            'port_override': self.port_override,
 9760            'secret_store_id': self.secret_store_id,
 9761            'tags': self.tags,
 9762            'username': self.username,
 9763        }
 9764
 9765    @classmethod
 9766    def from_dict(cls, d):
 9767        return cls(
 9768            bind_interface=d.get('bind_interface'),
 9769            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9770            egress_filter=d.get('egress_filter'),
 9771            healthy=d.get('healthy'),
 9772            hostname=d.get('hostname'),
 9773            id=d.get('id'),
 9774            name=d.get('name'),
 9775            password=d.get('password'),
 9776            port=d.get('port'),
 9777            port_override=d.get('port_override'),
 9778            secret_store_id=d.get('secret_store_id'),
 9779            tags=d.get('tags'),
 9780            username=d.get('username'),
 9781        )
 9782
 9783
 9784class RabbitMQAMQP091:
 9785    '''
 9786
 9787    '''
 9788    __slots__ = [
 9789        'bind_interface',
 9790        'egress_filter',
 9791        'healthy',
 9792        'hostname',
 9793        'id',
 9794        'name',
 9795        'password',
 9796        'port',
 9797        'port_override',
 9798        'secret_store_id',
 9799        'tags',
 9800        'tls_required',
 9801        'username',
 9802    ]
 9803
 9804    def __init__(
 9805        self,
 9806        bind_interface=None,
 9807        egress_filter=None,
 9808        healthy=None,
 9809        hostname=None,
 9810        id=None,
 9811        name=None,
 9812        password=None,
 9813        port=None,
 9814        port_override=None,
 9815        secret_store_id=None,
 9816        tags=None,
 9817        tls_required=None,
 9818        username=None,
 9819    ):
 9820        self.bind_interface = bind_interface if bind_interface is not None else ''
 9821        '''
 9822         Bind interface
 9823        '''
 9824        self.egress_filter = egress_filter if egress_filter is not None else ''
 9825        '''
 9826         A filter applied to the routing logic to pin datasource to nodes.
 9827        '''
 9828        self.healthy = healthy if healthy is not None else False
 9829        '''
 9830         True if the datasource is reachable and the credentials are valid.
 9831        '''
 9832        self.hostname = hostname if hostname is not None else ''
 9833        '''
 9834
 9835        '''
 9836        self.id = id if id is not None else ''
 9837        '''
 9838         Unique identifier of the Resource.
 9839        '''
 9840        self.name = name if name is not None else ''
 9841        '''
 9842         Unique human-readable name of the Resource.
 9843        '''
 9844        self.password = password if password is not None else ''
 9845        '''
 9846
 9847        '''
 9848        self.port = port if port is not None else 0
 9849        '''
 9850
 9851        '''
 9852        self.port_override = port_override if port_override is not None else 0
 9853        '''
 9854
 9855        '''
 9856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9857        '''
 9858         ID of the secret store containing credentials for this resource, if any.
 9859        '''
 9860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9861        '''
 9862         Tags is a map of key, value pairs.
 9863        '''
 9864        self.tls_required = tls_required if tls_required is not None else False
 9865        '''
 9866
 9867        '''
 9868        self.username = username if username is not None else ''
 9869        '''
 9870
 9871        '''
 9872
 9873    def __repr__(self):
 9874        return '<sdm.RabbitMQAMQP091 ' + \
 9875            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9876            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9877            'healthy: ' + repr(self.healthy) + ' ' +\
 9878            'hostname: ' + repr(self.hostname) + ' ' +\
 9879            'id: ' + repr(self.id) + ' ' +\
 9880            'name: ' + repr(self.name) + ' ' +\
 9881            'password: ' + repr(self.password) + ' ' +\
 9882            'port: ' + repr(self.port) + ' ' +\
 9883            'port_override: ' + repr(self.port_override) + ' ' +\
 9884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9885            'tags: ' + repr(self.tags) + ' ' +\
 9886            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9887            'username: ' + repr(self.username) + ' ' +\
 9888            '>'
 9889
 9890    def to_dict(self):
 9891        return {
 9892            'bind_interface': self.bind_interface,
 9893            'egress_filter': self.egress_filter,
 9894            'healthy': self.healthy,
 9895            'hostname': self.hostname,
 9896            'id': self.id,
 9897            'name': self.name,
 9898            'password': self.password,
 9899            'port': self.port,
 9900            'port_override': self.port_override,
 9901            'secret_store_id': self.secret_store_id,
 9902            'tags': self.tags,
 9903            'tls_required': self.tls_required,
 9904            'username': self.username,
 9905        }
 9906
 9907    @classmethod
 9908    def from_dict(cls, d):
 9909        return cls(
 9910            bind_interface=d.get('bind_interface'),
 9911            egress_filter=d.get('egress_filter'),
 9912            healthy=d.get('healthy'),
 9913            hostname=d.get('hostname'),
 9914            id=d.get('id'),
 9915            name=d.get('name'),
 9916            password=d.get('password'),
 9917            port=d.get('port'),
 9918            port_override=d.get('port_override'),
 9919            secret_store_id=d.get('secret_store_id'),
 9920            tags=d.get('tags'),
 9921            tls_required=d.get('tls_required'),
 9922            username=d.get('username'),
 9923        )
 9924
 9925
 9926class RateLimitMetadata:
 9927    '''
 9928     RateLimitMetadata contains information about remaining requests avaialable
 9929     to the user over some timeframe.
 9930    '''
 9931    __slots__ = [
 9932        'bucket',
 9933        'limit',
 9934        'remaining',
 9935        'reset_at',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        bucket=None,
 9941        limit=None,
 9942        remaining=None,
 9943        reset_at=None,
 9944    ):
 9945        self.bucket = bucket if bucket is not None else ''
 9946        '''
 9947         The bucket this user/token is associated with, which may be shared between
 9948         multiple users/tokens.
 9949        '''
 9950        self.limit = limit if limit is not None else 0
 9951        '''
 9952         How many total requests the user/token is authorized to make before being
 9953         rate limited.
 9954        '''
 9955        self.remaining = remaining if remaining is not None else 0
 9956        '''
 9957         How many remaining requests out of the limit are still avaialable.
 9958        '''
 9959        self.reset_at = reset_at if reset_at is not None else None
 9960        '''
 9961         The time when remaining will be reset to limit.
 9962        '''
 9963
 9964    def __repr__(self):
 9965        return '<sdm.RateLimitMetadata ' + \
 9966            'bucket: ' + repr(self.bucket) + ' ' +\
 9967            'limit: ' + repr(self.limit) + ' ' +\
 9968            'remaining: ' + repr(self.remaining) + ' ' +\
 9969            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9970            '>'
 9971
 9972    def to_dict(self):
 9973        return {
 9974            'bucket': self.bucket,
 9975            'limit': self.limit,
 9976            'remaining': self.remaining,
 9977            'reset_at': self.reset_at,
 9978        }
 9979
 9980    @classmethod
 9981    def from_dict(cls, d):
 9982        return cls(
 9983            bucket=d.get('bucket'),
 9984            limit=d.get('limit'),
 9985            remaining=d.get('remaining'),
 9986            reset_at=d.get('reset_at'),
 9987        )
 9988
 9989
 9990class RawTCP:
 9991    '''
 9992
 9993    '''
 9994    __slots__ = [
 9995        'bind_interface',
 9996        'egress_filter',
 9997        'healthy',
 9998        'hostname',
 9999        'id',
10000        'name',
10001        'port',
10002        'port_override',
10003        'secret_store_id',
10004        'tags',
10005    ]
10006
10007    def __init__(
10008        self,
10009        bind_interface=None,
10010        egress_filter=None,
10011        healthy=None,
10012        hostname=None,
10013        id=None,
10014        name=None,
10015        port=None,
10016        port_override=None,
10017        secret_store_id=None,
10018        tags=None,
10019    ):
10020        self.bind_interface = bind_interface if bind_interface is not None else ''
10021        '''
10022         Bind interface
10023        '''
10024        self.egress_filter = egress_filter if egress_filter is not None else ''
10025        '''
10026         A filter applied to the routing logic to pin datasource to nodes.
10027        '''
10028        self.healthy = healthy if healthy is not None else False
10029        '''
10030         True if the datasource is reachable and the credentials are valid.
10031        '''
10032        self.hostname = hostname if hostname is not None else ''
10033        '''
10034
10035        '''
10036        self.id = id if id is not None else ''
10037        '''
10038         Unique identifier of the Resource.
10039        '''
10040        self.name = name if name is not None else ''
10041        '''
10042         Unique human-readable name of the Resource.
10043        '''
10044        self.port = port if port is not None else 0
10045        '''
10046
10047        '''
10048        self.port_override = port_override if port_override is not None else 0
10049        '''
10050
10051        '''
10052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10053        '''
10054         ID of the secret store containing credentials for this resource, if any.
10055        '''
10056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10057        '''
10058         Tags is a map of key, value pairs.
10059        '''
10060
10061    def __repr__(self):
10062        return '<sdm.RawTCP ' + \
10063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10065            'healthy: ' + repr(self.healthy) + ' ' +\
10066            'hostname: ' + repr(self.hostname) + ' ' +\
10067            'id: ' + repr(self.id) + ' ' +\
10068            'name: ' + repr(self.name) + ' ' +\
10069            'port: ' + repr(self.port) + ' ' +\
10070            'port_override: ' + repr(self.port_override) + ' ' +\
10071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10072            'tags: ' + repr(self.tags) + ' ' +\
10073            '>'
10074
10075    def to_dict(self):
10076        return {
10077            'bind_interface': self.bind_interface,
10078            'egress_filter': self.egress_filter,
10079            'healthy': self.healthy,
10080            'hostname': self.hostname,
10081            'id': self.id,
10082            'name': self.name,
10083            'port': self.port,
10084            'port_override': self.port_override,
10085            'secret_store_id': self.secret_store_id,
10086            'tags': self.tags,
10087        }
10088
10089    @classmethod
10090    def from_dict(cls, d):
10091        return cls(
10092            bind_interface=d.get('bind_interface'),
10093            egress_filter=d.get('egress_filter'),
10094            healthy=d.get('healthy'),
10095            hostname=d.get('hostname'),
10096            id=d.get('id'),
10097            name=d.get('name'),
10098            port=d.get('port'),
10099            port_override=d.get('port_override'),
10100            secret_store_id=d.get('secret_store_id'),
10101            tags=d.get('tags'),
10102        )
10103
10104
10105class Redis:
10106    '''
10107
10108    '''
10109    __slots__ = [
10110        'bind_interface',
10111        'egress_filter',
10112        'healthy',
10113        'hostname',
10114        'id',
10115        'name',
10116        'password',
10117        'port',
10118        'port_override',
10119        'secret_store_id',
10120        'tags',
10121    ]
10122
10123    def __init__(
10124        self,
10125        bind_interface=None,
10126        egress_filter=None,
10127        healthy=None,
10128        hostname=None,
10129        id=None,
10130        name=None,
10131        password=None,
10132        port=None,
10133        port_override=None,
10134        secret_store_id=None,
10135        tags=None,
10136    ):
10137        self.bind_interface = bind_interface if bind_interface is not None else ''
10138        '''
10139         Bind interface
10140        '''
10141        self.egress_filter = egress_filter if egress_filter is not None else ''
10142        '''
10143         A filter applied to the routing logic to pin datasource to nodes.
10144        '''
10145        self.healthy = healthy if healthy is not None else False
10146        '''
10147         True if the datasource is reachable and the credentials are valid.
10148        '''
10149        self.hostname = hostname if hostname is not None else ''
10150        '''
10151
10152        '''
10153        self.id = id if id is not None else ''
10154        '''
10155         Unique identifier of the Resource.
10156        '''
10157        self.name = name if name is not None else ''
10158        '''
10159         Unique human-readable name of the Resource.
10160        '''
10161        self.password = password if password is not None else ''
10162        '''
10163
10164        '''
10165        self.port = port if port is not None else 0
10166        '''
10167
10168        '''
10169        self.port_override = port_override if port_override is not None else 0
10170        '''
10171
10172        '''
10173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10174        '''
10175         ID of the secret store containing credentials for this resource, if any.
10176        '''
10177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10178        '''
10179         Tags is a map of key, value pairs.
10180        '''
10181
10182    def __repr__(self):
10183        return '<sdm.Redis ' + \
10184            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10186            'healthy: ' + repr(self.healthy) + ' ' +\
10187            'hostname: ' + repr(self.hostname) + ' ' +\
10188            'id: ' + repr(self.id) + ' ' +\
10189            'name: ' + repr(self.name) + ' ' +\
10190            'password: ' + repr(self.password) + ' ' +\
10191            'port: ' + repr(self.port) + ' ' +\
10192            'port_override: ' + repr(self.port_override) + ' ' +\
10193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10194            'tags: ' + repr(self.tags) + ' ' +\
10195            '>'
10196
10197    def to_dict(self):
10198        return {
10199            'bind_interface': self.bind_interface,
10200            'egress_filter': self.egress_filter,
10201            'healthy': self.healthy,
10202            'hostname': self.hostname,
10203            'id': self.id,
10204            'name': self.name,
10205            'password': self.password,
10206            'port': self.port,
10207            'port_override': self.port_override,
10208            'secret_store_id': self.secret_store_id,
10209            'tags': self.tags,
10210        }
10211
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            bind_interface=d.get('bind_interface'),
10216            egress_filter=d.get('egress_filter'),
10217            healthy=d.get('healthy'),
10218            hostname=d.get('hostname'),
10219            id=d.get('id'),
10220            name=d.get('name'),
10221            password=d.get('password'),
10222            port=d.get('port'),
10223            port_override=d.get('port_override'),
10224            secret_store_id=d.get('secret_store_id'),
10225            tags=d.get('tags'),
10226        )
10227
10228
10229class Redshift:
10230    '''
10231
10232    '''
10233    __slots__ = [
10234        'bind_interface',
10235        'database',
10236        'egress_filter',
10237        'healthy',
10238        'hostname',
10239        'id',
10240        'name',
10241        'override_database',
10242        'password',
10243        'port',
10244        'port_override',
10245        'secret_store_id',
10246        'tags',
10247        'username',
10248    ]
10249
10250    def __init__(
10251        self,
10252        bind_interface=None,
10253        database=None,
10254        egress_filter=None,
10255        healthy=None,
10256        hostname=None,
10257        id=None,
10258        name=None,
10259        override_database=None,
10260        password=None,
10261        port=None,
10262        port_override=None,
10263        secret_store_id=None,
10264        tags=None,
10265        username=None,
10266    ):
10267        self.bind_interface = bind_interface if bind_interface is not None else ''
10268        '''
10269         Bind interface
10270        '''
10271        self.database = database if database is not None else ''
10272        '''
10273
10274        '''
10275        self.egress_filter = egress_filter if egress_filter is not None else ''
10276        '''
10277         A filter applied to the routing logic to pin datasource to nodes.
10278        '''
10279        self.healthy = healthy if healthy is not None else False
10280        '''
10281         True if the datasource is reachable and the credentials are valid.
10282        '''
10283        self.hostname = hostname if hostname is not None else ''
10284        '''
10285
10286        '''
10287        self.id = id if id is not None else ''
10288        '''
10289         Unique identifier of the Resource.
10290        '''
10291        self.name = name if name is not None else ''
10292        '''
10293         Unique human-readable name of the Resource.
10294        '''
10295        self.override_database = override_database if override_database is not None else False
10296        '''
10297
10298        '''
10299        self.password = password if password is not None else ''
10300        '''
10301
10302        '''
10303        self.port = port if port is not None else 0
10304        '''
10305
10306        '''
10307        self.port_override = port_override if port_override is not None else 0
10308        '''
10309
10310        '''
10311        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10312        '''
10313         ID of the secret store containing credentials for this resource, if any.
10314        '''
10315        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10316        '''
10317         Tags is a map of key, value pairs.
10318        '''
10319        self.username = username if username is not None else ''
10320        '''
10321
10322        '''
10323
10324    def __repr__(self):
10325        return '<sdm.Redshift ' + \
10326            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10327            'database: ' + repr(self.database) + ' ' +\
10328            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10329            'healthy: ' + repr(self.healthy) + ' ' +\
10330            'hostname: ' + repr(self.hostname) + ' ' +\
10331            'id: ' + repr(self.id) + ' ' +\
10332            'name: ' + repr(self.name) + ' ' +\
10333            'override_database: ' + repr(self.override_database) + ' ' +\
10334            'password: ' + repr(self.password) + ' ' +\
10335            'port: ' + repr(self.port) + ' ' +\
10336            'port_override: ' + repr(self.port_override) + ' ' +\
10337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10338            'tags: ' + repr(self.tags) + ' ' +\
10339            'username: ' + repr(self.username) + ' ' +\
10340            '>'
10341
10342    def to_dict(self):
10343        return {
10344            'bind_interface': self.bind_interface,
10345            'database': self.database,
10346            'egress_filter': self.egress_filter,
10347            'healthy': self.healthy,
10348            'hostname': self.hostname,
10349            'id': self.id,
10350            'name': self.name,
10351            'override_database': self.override_database,
10352            'password': self.password,
10353            'port': self.port,
10354            'port_override': self.port_override,
10355            'secret_store_id': self.secret_store_id,
10356            'tags': self.tags,
10357            'username': self.username,
10358        }
10359
10360    @classmethod
10361    def from_dict(cls, d):
10362        return cls(
10363            bind_interface=d.get('bind_interface'),
10364            database=d.get('database'),
10365            egress_filter=d.get('egress_filter'),
10366            healthy=d.get('healthy'),
10367            hostname=d.get('hostname'),
10368            id=d.get('id'),
10369            name=d.get('name'),
10370            override_database=d.get('override_database'),
10371            password=d.get('password'),
10372            port=d.get('port'),
10373            port_override=d.get('port_override'),
10374            secret_store_id=d.get('secret_store_id'),
10375            tags=d.get('tags'),
10376            username=d.get('username'),
10377        )
10378
10379
10380class Relay:
10381    '''
10382     Relay represents a StrongDM CLI installation running in relay mode.
10383    '''
10384    __slots__ = [
10385        'gateway_filter',
10386        'id',
10387        'name',
10388        'state',
10389        'tags',
10390    ]
10391
10392    def __init__(
10393        self,
10394        gateway_filter=None,
10395        id=None,
10396        name=None,
10397        state=None,
10398        tags=None,
10399    ):
10400        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10401        '''
10402         GatewayFilter can be used to restrict the peering between relays and
10403         gateways.
10404        '''
10405        self.id = id if id is not None else ''
10406        '''
10407         Unique identifier of the Relay.
10408        '''
10409        self.name = name if name is not None else ''
10410        '''
10411         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10412        '''
10413        self.state = state if state is not None else ''
10414        '''
10415         The current state of the relay. One of: "new", "verifying_restart",
10416         "awaiting_restart", "restarting", "started", "stopped", "dead",
10417         "unknown".
10418        '''
10419        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10420        '''
10421         Tags is a map of key, value pairs.
10422        '''
10423
10424    def __repr__(self):
10425        return '<sdm.Relay ' + \
10426            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10427            'id: ' + repr(self.id) + ' ' +\
10428            'name: ' + repr(self.name) + ' ' +\
10429            'state: ' + repr(self.state) + ' ' +\
10430            'tags: ' + repr(self.tags) + ' ' +\
10431            '>'
10432
10433    def to_dict(self):
10434        return {
10435            'gateway_filter': self.gateway_filter,
10436            'id': self.id,
10437            'name': self.name,
10438            'state': self.state,
10439            'tags': self.tags,
10440        }
10441
10442    @classmethod
10443    def from_dict(cls, d):
10444        return cls(
10445            gateway_filter=d.get('gateway_filter'),
10446            id=d.get('id'),
10447            name=d.get('name'),
10448            state=d.get('state'),
10449            tags=d.get('tags'),
10450        )
10451
10452
10453class RemoteIdentity:
10454    '''
10455     RemoteIdentities define the username to be used for a specific account
10456     when connecting to a remote resource using that group.
10457    '''
10458    __slots__ = [
10459        'account_id',
10460        'id',
10461        'remote_identity_group_id',
10462        'username',
10463    ]
10464
10465    def __init__(
10466        self,
10467        account_id=None,
10468        id=None,
10469        remote_identity_group_id=None,
10470        username=None,
10471    ):
10472        self.account_id = account_id if account_id is not None else ''
10473        '''
10474         The account for this remote identity.
10475        '''
10476        self.id = id if id is not None else ''
10477        '''
10478         Unique identifier of the RemoteIdentity.
10479        '''
10480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10481        '''
10482         The remote identity group.
10483        '''
10484        self.username = username if username is not None else ''
10485        '''
10486         The username to be used as the remote identity for this account.
10487        '''
10488
10489    def __repr__(self):
10490        return '<sdm.RemoteIdentity ' + \
10491            'account_id: ' + repr(self.account_id) + ' ' +\
10492            'id: ' + repr(self.id) + ' ' +\
10493            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10494            'username: ' + repr(self.username) + ' ' +\
10495            '>'
10496
10497    def to_dict(self):
10498        return {
10499            'account_id': self.account_id,
10500            'id': self.id,
10501            'remote_identity_group_id': self.remote_identity_group_id,
10502            'username': self.username,
10503        }
10504
10505    @classmethod
10506    def from_dict(cls, d):
10507        return cls(
10508            account_id=d.get('account_id'),
10509            id=d.get('id'),
10510            remote_identity_group_id=d.get('remote_identity_group_id'),
10511            username=d.get('username'),
10512        )
10513
10514
10515class RemoteIdentityCreateResponse:
10516    '''
10517     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10518    '''
10519    __slots__ = [
10520        'meta',
10521        'rate_limit',
10522        'remote_identity',
10523    ]
10524
10525    def __init__(
10526        self,
10527        meta=None,
10528        rate_limit=None,
10529        remote_identity=None,
10530    ):
10531        self.meta = meta if meta is not None else None
10532        '''
10533         Reserved for future use.
10534        '''
10535        self.rate_limit = rate_limit if rate_limit is not None else None
10536        '''
10537         Rate limit information.
10538        '''
10539        self.remote_identity = remote_identity if remote_identity is not None else None
10540        '''
10541         The created RemoteIdentity.
10542        '''
10543
10544    def __repr__(self):
10545        return '<sdm.RemoteIdentityCreateResponse ' + \
10546            'meta: ' + repr(self.meta) + ' ' +\
10547            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10548            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10549            '>'
10550
10551    def to_dict(self):
10552        return {
10553            'meta': self.meta,
10554            'rate_limit': self.rate_limit,
10555            'remote_identity': self.remote_identity,
10556        }
10557
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            meta=d.get('meta'),
10562            rate_limit=d.get('rate_limit'),
10563            remote_identity=d.get('remote_identity'),
10564        )
10565
10566
10567class RemoteIdentityDeleteResponse:
10568    '''
10569     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10570    '''
10571    __slots__ = [
10572        'meta',
10573        'rate_limit',
10574    ]
10575
10576    def __init__(
10577        self,
10578        meta=None,
10579        rate_limit=None,
10580    ):
10581        self.meta = meta if meta is not None else None
10582        '''
10583         Reserved for future use.
10584        '''
10585        self.rate_limit = rate_limit if rate_limit is not None else None
10586        '''
10587         Rate limit information.
10588        '''
10589
10590    def __repr__(self):
10591        return '<sdm.RemoteIdentityDeleteResponse ' + \
10592            'meta: ' + repr(self.meta) + ' ' +\
10593            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10594            '>'
10595
10596    def to_dict(self):
10597        return {
10598            'meta': self.meta,
10599            'rate_limit': self.rate_limit,
10600        }
10601
10602    @classmethod
10603    def from_dict(cls, d):
10604        return cls(
10605            meta=d.get('meta'),
10606            rate_limit=d.get('rate_limit'),
10607        )
10608
10609
10610class RemoteIdentityGetResponse:
10611    '''
10612     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10613    '''
10614    __slots__ = [
10615        'meta',
10616        'rate_limit',
10617        'remote_identity',
10618    ]
10619
10620    def __init__(
10621        self,
10622        meta=None,
10623        rate_limit=None,
10624        remote_identity=None,
10625    ):
10626        self.meta = meta if meta is not None else None
10627        '''
10628         Reserved for future use.
10629        '''
10630        self.rate_limit = rate_limit if rate_limit is not None else None
10631        '''
10632         Rate limit information.
10633        '''
10634        self.remote_identity = remote_identity if remote_identity is not None else None
10635        '''
10636         The requested RemoteIdentity.
10637        '''
10638
10639    def __repr__(self):
10640        return '<sdm.RemoteIdentityGetResponse ' + \
10641            'meta: ' + repr(self.meta) + ' ' +\
10642            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10643            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10644            '>'
10645
10646    def to_dict(self):
10647        return {
10648            'meta': self.meta,
10649            'rate_limit': self.rate_limit,
10650            'remote_identity': self.remote_identity,
10651        }
10652
10653    @classmethod
10654    def from_dict(cls, d):
10655        return cls(
10656            meta=d.get('meta'),
10657            rate_limit=d.get('rate_limit'),
10658            remote_identity=d.get('remote_identity'),
10659        )
10660
10661
10662class RemoteIdentityGroup:
10663    '''
10664     A RemoteIdentityGroup defines a group of remote identities.
10665    '''
10666    __slots__ = [
10667        'id',
10668        'name',
10669    ]
10670
10671    def __init__(
10672        self,
10673        id=None,
10674        name=None,
10675    ):
10676        self.id = id if id is not None else ''
10677        '''
10678         Unique identifier of the RemoteIdentityGroup.
10679        '''
10680        self.name = name if name is not None else ''
10681        '''
10682         Unique human-readable name of the RemoteIdentityGroup.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RemoteIdentityGroup ' + \
10687            'id: ' + repr(self.id) + ' ' +\
10688            'name: ' + repr(self.name) + ' ' +\
10689            '>'
10690
10691    def to_dict(self):
10692        return {
10693            'id': self.id,
10694            'name': self.name,
10695        }
10696
10697    @classmethod
10698    def from_dict(cls, d):
10699        return cls(
10700            id=d.get('id'),
10701            name=d.get('name'),
10702        )
10703
10704
10705class RemoteIdentityGroupGetResponse:
10706    '''
10707     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10708    '''
10709    __slots__ = [
10710        'meta',
10711        'rate_limit',
10712        'remote_identity_group',
10713    ]
10714
10715    def __init__(
10716        self,
10717        meta=None,
10718        rate_limit=None,
10719        remote_identity_group=None,
10720    ):
10721        self.meta = meta if meta is not None else None
10722        '''
10723         Reserved for future use.
10724        '''
10725        self.rate_limit = rate_limit if rate_limit is not None else None
10726        '''
10727         Rate limit information.
10728        '''
10729        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10730        '''
10731         The requested RemoteIdentityGroup.
10732        '''
10733
10734    def __repr__(self):
10735        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10736            'meta: ' + repr(self.meta) + ' ' +\
10737            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10738            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10739            '>'
10740
10741    def to_dict(self):
10742        return {
10743            'meta': self.meta,
10744            'rate_limit': self.rate_limit,
10745            'remote_identity_group': self.remote_identity_group,
10746        }
10747
10748    @classmethod
10749    def from_dict(cls, d):
10750        return cls(
10751            meta=d.get('meta'),
10752            rate_limit=d.get('rate_limit'),
10753            remote_identity_group=d.get('remote_identity_group'),
10754        )
10755
10756
10757class RemoteIdentityUpdateResponse:
10758    '''
10759     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10760     a RemoteIdentityUpdateRequest.
10761    '''
10762    __slots__ = [
10763        'meta',
10764        'rate_limit',
10765        'remote_identity',
10766    ]
10767
10768    def __init__(
10769        self,
10770        meta=None,
10771        rate_limit=None,
10772        remote_identity=None,
10773    ):
10774        self.meta = meta if meta is not None else None
10775        '''
10776         Reserved for future use.
10777        '''
10778        self.rate_limit = rate_limit if rate_limit is not None else None
10779        '''
10780         Rate limit information.
10781        '''
10782        self.remote_identity = remote_identity if remote_identity is not None else None
10783        '''
10784         The updated RemoteIdentity.
10785        '''
10786
10787    def __repr__(self):
10788        return '<sdm.RemoteIdentityUpdateResponse ' + \
10789            'meta: ' + repr(self.meta) + ' ' +\
10790            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10791            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10792            '>'
10793
10794    def to_dict(self):
10795        return {
10796            'meta': self.meta,
10797            'rate_limit': self.rate_limit,
10798            'remote_identity': self.remote_identity,
10799        }
10800
10801    @classmethod
10802    def from_dict(cls, d):
10803        return cls(
10804            meta=d.get('meta'),
10805            rate_limit=d.get('rate_limit'),
10806            remote_identity=d.get('remote_identity'),
10807        )
10808
10809
10810class ResourceCreateResponse:
10811    '''
10812     ResourceCreateResponse reports how the Resources were created in the system.
10813    '''
10814    __slots__ = [
10815        'meta',
10816        'rate_limit',
10817        'resource',
10818    ]
10819
10820    def __init__(
10821        self,
10822        meta=None,
10823        rate_limit=None,
10824        resource=None,
10825    ):
10826        self.meta = meta if meta is not None else None
10827        '''
10828         Reserved for future use.
10829        '''
10830        self.rate_limit = rate_limit if rate_limit is not None else None
10831        '''
10832         Rate limit information.
10833        '''
10834        self.resource = resource if resource is not None else None
10835        '''
10836         The created Resource.
10837        '''
10838
10839    def __repr__(self):
10840        return '<sdm.ResourceCreateResponse ' + \
10841            'meta: ' + repr(self.meta) + ' ' +\
10842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10843            'resource: ' + repr(self.resource) + ' ' +\
10844            '>'
10845
10846    def to_dict(self):
10847        return {
10848            'meta': self.meta,
10849            'rate_limit': self.rate_limit,
10850            'resource': self.resource,
10851        }
10852
10853    @classmethod
10854    def from_dict(cls, d):
10855        return cls(
10856            meta=d.get('meta'),
10857            rate_limit=d.get('rate_limit'),
10858            resource=d.get('resource'),
10859        )
10860
10861
10862class ResourceDeleteResponse:
10863    '''
10864     ResourceDeleteResponse returns information about a Resource that was deleted.
10865    '''
10866    __slots__ = [
10867        'meta',
10868        'rate_limit',
10869    ]
10870
10871    def __init__(
10872        self,
10873        meta=None,
10874        rate_limit=None,
10875    ):
10876        self.meta = meta if meta is not None else None
10877        '''
10878         Reserved for future use.
10879        '''
10880        self.rate_limit = rate_limit if rate_limit is not None else None
10881        '''
10882         Rate limit information.
10883        '''
10884
10885    def __repr__(self):
10886        return '<sdm.ResourceDeleteResponse ' + \
10887            'meta: ' + repr(self.meta) + ' ' +\
10888            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10889            '>'
10890
10891    def to_dict(self):
10892        return {
10893            'meta': self.meta,
10894            'rate_limit': self.rate_limit,
10895        }
10896
10897    @classmethod
10898    def from_dict(cls, d):
10899        return cls(
10900            meta=d.get('meta'),
10901            rate_limit=d.get('rate_limit'),
10902        )
10903
10904
10905class ResourceGetResponse:
10906    '''
10907     ResourceGetResponse returns a requested Resource.
10908    '''
10909    __slots__ = [
10910        'meta',
10911        'rate_limit',
10912        'resource',
10913    ]
10914
10915    def __init__(
10916        self,
10917        meta=None,
10918        rate_limit=None,
10919        resource=None,
10920    ):
10921        self.meta = meta if meta is not None else None
10922        '''
10923         Reserved for future use.
10924        '''
10925        self.rate_limit = rate_limit if rate_limit is not None else None
10926        '''
10927         Rate limit information.
10928        '''
10929        self.resource = resource if resource is not None else None
10930        '''
10931         The requested Resource.
10932        '''
10933
10934    def __repr__(self):
10935        return '<sdm.ResourceGetResponse ' + \
10936            'meta: ' + repr(self.meta) + ' ' +\
10937            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10938            'resource: ' + repr(self.resource) + ' ' +\
10939            '>'
10940
10941    def to_dict(self):
10942        return {
10943            'meta': self.meta,
10944            'rate_limit': self.rate_limit,
10945            'resource': self.resource,
10946        }
10947
10948    @classmethod
10949    def from_dict(cls, d):
10950        return cls(
10951            meta=d.get('meta'),
10952            rate_limit=d.get('rate_limit'),
10953            resource=d.get('resource'),
10954        )
10955
10956
10957class ResourceUpdateResponse:
10958    '''
10959     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10960     a ResourceUpdateRequest.
10961    '''
10962    __slots__ = [
10963        'meta',
10964        'rate_limit',
10965        'resource',
10966    ]
10967
10968    def __init__(
10969        self,
10970        meta=None,
10971        rate_limit=None,
10972        resource=None,
10973    ):
10974        self.meta = meta if meta is not None else None
10975        '''
10976         Reserved for future use.
10977        '''
10978        self.rate_limit = rate_limit if rate_limit is not None else None
10979        '''
10980         Rate limit information.
10981        '''
10982        self.resource = resource if resource is not None else None
10983        '''
10984         The updated Resource.
10985        '''
10986
10987    def __repr__(self):
10988        return '<sdm.ResourceUpdateResponse ' + \
10989            'meta: ' + repr(self.meta) + ' ' +\
10990            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10991            'resource: ' + repr(self.resource) + ' ' +\
10992            '>'
10993
10994    def to_dict(self):
10995        return {
10996            'meta': self.meta,
10997            'rate_limit': self.rate_limit,
10998            'resource': self.resource,
10999        }
11000
11001    @classmethod
11002    def from_dict(cls, d):
11003        return cls(
11004            meta=d.get('meta'),
11005            rate_limit=d.get('rate_limit'),
11006            resource=d.get('resource'),
11007        )
11008
11009
11010class Role:
11011    '''
11012     A Role has a list of access rules which determine which Resources the members
11013     of the Role have access to. An Account can be a member of multiple Roles via
11014     AccountAttachments.
11015    '''
11016    __slots__ = [
11017        'access_rules',
11018        'composite',
11019        'id',
11020        'name',
11021        'tags',
11022    ]
11023
11024    def __init__(
11025        self,
11026        access_rules=None,
11027        composite=None,
11028        id=None,
11029        name=None,
11030        tags=None,
11031    ):
11032        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11033        )
11034        '''
11035         AccessRules is a list of access rules defining the resources this Role has access to.
11036        '''
11037        self.composite = composite if composite is not None else False
11038        '''
11039         Composite is true if the Role is a composite role.
11040         
11041         Deprecated: composite roles are deprecated, use multi-role via
11042         AccountAttachments instead.
11043        '''
11044        self.id = id if id is not None else ''
11045        '''
11046         Unique identifier of the Role.
11047        '''
11048        self.name = name if name is not None else ''
11049        '''
11050         Unique human-readable name of the Role.
11051        '''
11052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11053        '''
11054         Tags is a map of key, value pairs.
11055        '''
11056
11057    def __repr__(self):
11058        return '<sdm.Role ' + \
11059            'access_rules: ' + repr(self.access_rules) + ' ' +\
11060            'composite: ' + repr(self.composite) + ' ' +\
11061            'id: ' + repr(self.id) + ' ' +\
11062            'name: ' + repr(self.name) + ' ' +\
11063            'tags: ' + repr(self.tags) + ' ' +\
11064            '>'
11065
11066    def to_dict(self):
11067        return {
11068            'access_rules': self.access_rules,
11069            'composite': self.composite,
11070            'id': self.id,
11071            'name': self.name,
11072            'tags': self.tags,
11073        }
11074
11075    @classmethod
11076    def from_dict(cls, d):
11077        return cls(
11078            access_rules=d.get('access_rules'),
11079            composite=d.get('composite'),
11080            id=d.get('id'),
11081            name=d.get('name'),
11082            tags=d.get('tags'),
11083        )
11084
11085
11086class RoleAttachment:
11087    '''
11088     A RoleAttachment assigns a role to a composite role.
11089     
11090     Deprecated: use multi-role via AccountAttachments instead.
11091    '''
11092    __slots__ = [
11093        'attached_role_id',
11094        'composite_role_id',
11095        'id',
11096    ]
11097
11098    def __init__(
11099        self,
11100        attached_role_id=None,
11101        composite_role_id=None,
11102        id=None,
11103    ):
11104        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11105        '''
11106         The id of the attached role of this RoleAttachment.
11107        '''
11108        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11109        '''
11110         The id of the composite role of this RoleAttachment.
11111        '''
11112        self.id = id if id is not None else ''
11113        '''
11114         Unique identifier of the RoleAttachment.
11115        '''
11116
11117    def __repr__(self):
11118        return '<sdm.RoleAttachment ' + \
11119            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
11120            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
11121            'id: ' + repr(self.id) + ' ' +\
11122            '>'
11123
11124    def to_dict(self):
11125        return {
11126            'attached_role_id': self.attached_role_id,
11127            'composite_role_id': self.composite_role_id,
11128            'id': self.id,
11129        }
11130
11131    @classmethod
11132    def from_dict(cls, d):
11133        return cls(
11134            attached_role_id=d.get('attached_role_id'),
11135            composite_role_id=d.get('composite_role_id'),
11136            id=d.get('id'),
11137        )
11138
11139
11140class RoleAttachmentCreateResponse:
11141    '''
11142     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
11143     
11144     Deprecated: use multi-role via AccountAttachments instead.
11145    '''
11146    __slots__ = [
11147        'meta',
11148        'rate_limit',
11149        'role_attachment',
11150    ]
11151
11152    def __init__(
11153        self,
11154        meta=None,
11155        rate_limit=None,
11156        role_attachment=None,
11157    ):
11158        self.meta = meta if meta is not None else None
11159        '''
11160         Reserved for future use.
11161        '''
11162        self.rate_limit = rate_limit if rate_limit is not None else None
11163        '''
11164         Rate limit information.
11165        '''
11166        self.role_attachment = role_attachment if role_attachment is not None else None
11167        '''
11168         The created RoleAttachment.
11169        '''
11170
11171    def __repr__(self):
11172        return '<sdm.RoleAttachmentCreateResponse ' + \
11173            'meta: ' + repr(self.meta) + ' ' +\
11174            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11175            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11176            '>'
11177
11178    def to_dict(self):
11179        return {
11180            'meta': self.meta,
11181            'rate_limit': self.rate_limit,
11182            'role_attachment': self.role_attachment,
11183        }
11184
11185    @classmethod
11186    def from_dict(cls, d):
11187        return cls(
11188            meta=d.get('meta'),
11189            rate_limit=d.get('rate_limit'),
11190            role_attachment=d.get('role_attachment'),
11191        )
11192
11193
11194class RoleAttachmentDeleteResponse:
11195    '''
11196     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
11197     
11198     Deprecated: use multi-role via AccountAttachments instead.
11199    '''
11200    __slots__ = [
11201        'meta',
11202        'rate_limit',
11203    ]
11204
11205    def __init__(
11206        self,
11207        meta=None,
11208        rate_limit=None,
11209    ):
11210        self.meta = meta if meta is not None else None
11211        '''
11212         Reserved for future use.
11213        '''
11214        self.rate_limit = rate_limit if rate_limit is not None else None
11215        '''
11216         Rate limit information.
11217        '''
11218
11219    def __repr__(self):
11220        return '<sdm.RoleAttachmentDeleteResponse ' + \
11221            'meta: ' + repr(self.meta) + ' ' +\
11222            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11223            '>'
11224
11225    def to_dict(self):
11226        return {
11227            'meta': self.meta,
11228            'rate_limit': self.rate_limit,
11229        }
11230
11231    @classmethod
11232    def from_dict(cls, d):
11233        return cls(
11234            meta=d.get('meta'),
11235            rate_limit=d.get('rate_limit'),
11236        )
11237
11238
11239class RoleAttachmentGetResponse:
11240    '''
11241     RoleAttachmentGetResponse returns a requested RoleAttachment.
11242     
11243     Deprecated: use multi-role via AccountAttachments instead.
11244    '''
11245    __slots__ = [
11246        'meta',
11247        'rate_limit',
11248        'role_attachment',
11249    ]
11250
11251    def __init__(
11252        self,
11253        meta=None,
11254        rate_limit=None,
11255        role_attachment=None,
11256    ):
11257        self.meta = meta if meta is not None else None
11258        '''
11259         Reserved for future use.
11260        '''
11261        self.rate_limit = rate_limit if rate_limit is not None else None
11262        '''
11263         Rate limit information.
11264        '''
11265        self.role_attachment = role_attachment if role_attachment is not None else None
11266        '''
11267         The requested RoleAttachment.
11268        '''
11269
11270    def __repr__(self):
11271        return '<sdm.RoleAttachmentGetResponse ' + \
11272            'meta: ' + repr(self.meta) + ' ' +\
11273            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11274            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11275            '>'
11276
11277    def to_dict(self):
11278        return {
11279            'meta': self.meta,
11280            'rate_limit': self.rate_limit,
11281            'role_attachment': self.role_attachment,
11282        }
11283
11284    @classmethod
11285    def from_dict(cls, d):
11286        return cls(
11287            meta=d.get('meta'),
11288            rate_limit=d.get('rate_limit'),
11289            role_attachment=d.get('role_attachment'),
11290        )
11291
11292
11293class RoleCreateResponse:
11294    '''
11295     RoleCreateResponse reports how the Roles were created in the system. It can
11296     communicate partial successes or failures.
11297    '''
11298    __slots__ = [
11299        'meta',
11300        'rate_limit',
11301        'role',
11302    ]
11303
11304    def __init__(
11305        self,
11306        meta=None,
11307        rate_limit=None,
11308        role=None,
11309    ):
11310        self.meta = meta if meta is not None else None
11311        '''
11312         Reserved for future use.
11313        '''
11314        self.rate_limit = rate_limit if rate_limit is not None else None
11315        '''
11316         Rate limit information.
11317        '''
11318        self.role = role if role is not None else None
11319        '''
11320         The created Role.
11321        '''
11322
11323    def __repr__(self):
11324        return '<sdm.RoleCreateResponse ' + \
11325            'meta: ' + repr(self.meta) + ' ' +\
11326            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11327            'role: ' + repr(self.role) + ' ' +\
11328            '>'
11329
11330    def to_dict(self):
11331        return {
11332            'meta': self.meta,
11333            'rate_limit': self.rate_limit,
11334            'role': self.role,
11335        }
11336
11337    @classmethod
11338    def from_dict(cls, d):
11339        return cls(
11340            meta=d.get('meta'),
11341            rate_limit=d.get('rate_limit'),
11342            role=d.get('role'),
11343        )
11344
11345
11346class RoleDeleteResponse:
11347    '''
11348     RoleDeleteResponse returns information about a Role that was deleted.
11349    '''
11350    __slots__ = [
11351        'meta',
11352        'rate_limit',
11353    ]
11354
11355    def __init__(
11356        self,
11357        meta=None,
11358        rate_limit=None,
11359    ):
11360        self.meta = meta if meta is not None else None
11361        '''
11362         Reserved for future use.
11363        '''
11364        self.rate_limit = rate_limit if rate_limit is not None else None
11365        '''
11366         Rate limit information.
11367        '''
11368
11369    def __repr__(self):
11370        return '<sdm.RoleDeleteResponse ' + \
11371            'meta: ' + repr(self.meta) + ' ' +\
11372            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11373            '>'
11374
11375    def to_dict(self):
11376        return {
11377            'meta': self.meta,
11378            'rate_limit': self.rate_limit,
11379        }
11380
11381    @classmethod
11382    def from_dict(cls, d):
11383        return cls(
11384            meta=d.get('meta'),
11385            rate_limit=d.get('rate_limit'),
11386        )
11387
11388
11389class RoleGetResponse:
11390    '''
11391     RoleGetResponse returns a requested Role.
11392    '''
11393    __slots__ = [
11394        'meta',
11395        'rate_limit',
11396        'role',
11397    ]
11398
11399    def __init__(
11400        self,
11401        meta=None,
11402        rate_limit=None,
11403        role=None,
11404    ):
11405        self.meta = meta if meta is not None else None
11406        '''
11407         Reserved for future use.
11408        '''
11409        self.rate_limit = rate_limit if rate_limit is not None else None
11410        '''
11411         Rate limit information.
11412        '''
11413        self.role = role if role is not None else None
11414        '''
11415         The requested Role.
11416        '''
11417
11418    def __repr__(self):
11419        return '<sdm.RoleGetResponse ' + \
11420            'meta: ' + repr(self.meta) + ' ' +\
11421            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11422            'role: ' + repr(self.role) + ' ' +\
11423            '>'
11424
11425    def to_dict(self):
11426        return {
11427            'meta': self.meta,
11428            'rate_limit': self.rate_limit,
11429            'role': self.role,
11430        }
11431
11432    @classmethod
11433    def from_dict(cls, d):
11434        return cls(
11435            meta=d.get('meta'),
11436            rate_limit=d.get('rate_limit'),
11437            role=d.get('role'),
11438        )
11439
11440
11441class RoleGrant:
11442    '''
11443     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
11444     
11445     Deprecated: use Role access rules instead.
11446    '''
11447    __slots__ = [
11448        'id',
11449        'resource_id',
11450        'role_id',
11451    ]
11452
11453    def __init__(
11454        self,
11455        id=None,
11456        resource_id=None,
11457        role_id=None,
11458    ):
11459        self.id = id if id is not None else ''
11460        '''
11461         Unique identifier of the RoleGrant.
11462        '''
11463        self.resource_id = resource_id if resource_id is not None else ''
11464        '''
11465         The id of the resource of this RoleGrant.
11466        '''
11467        self.role_id = role_id if role_id is not None else ''
11468        '''
11469         The id of the attached role of this RoleGrant.
11470        '''
11471
11472    def __repr__(self):
11473        return '<sdm.RoleGrant ' + \
11474            'id: ' + repr(self.id) + ' ' +\
11475            'resource_id: ' + repr(self.resource_id) + ' ' +\
11476            'role_id: ' + repr(self.role_id) + ' ' +\
11477            '>'
11478
11479    def to_dict(self):
11480        return {
11481            'id': self.id,
11482            'resource_id': self.resource_id,
11483            'role_id': self.role_id,
11484        }
11485
11486    @classmethod
11487    def from_dict(cls, d):
11488        return cls(
11489            id=d.get('id'),
11490            resource_id=d.get('resource_id'),
11491            role_id=d.get('role_id'),
11492        )
11493
11494
11495class RoleGrantCreateResponse:
11496    '''
11497     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
11498     
11499     Deprecated: use Role access rules instead.
11500    '''
11501    __slots__ = [
11502        'meta',
11503        'rate_limit',
11504        'role_grant',
11505    ]
11506
11507    def __init__(
11508        self,
11509        meta=None,
11510        rate_limit=None,
11511        role_grant=None,
11512    ):
11513        self.meta = meta if meta is not None else None
11514        '''
11515         Reserved for future use.
11516        '''
11517        self.rate_limit = rate_limit if rate_limit is not None else None
11518        '''
11519         Rate limit information.
11520        '''
11521        self.role_grant = role_grant if role_grant is not None else None
11522        '''
11523         The created RoleGrant.
11524        '''
11525
11526    def __repr__(self):
11527        return '<sdm.RoleGrantCreateResponse ' + \
11528            'meta: ' + repr(self.meta) + ' ' +\
11529            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11530            'role_grant: ' + repr(self.role_grant) + ' ' +\
11531            '>'
11532
11533    def to_dict(self):
11534        return {
11535            'meta': self.meta,
11536            'rate_limit': self.rate_limit,
11537            'role_grant': self.role_grant,
11538        }
11539
11540    @classmethod
11541    def from_dict(cls, d):
11542        return cls(
11543            meta=d.get('meta'),
11544            rate_limit=d.get('rate_limit'),
11545            role_grant=d.get('role_grant'),
11546        )
11547
11548
11549class RoleGrantDeleteResponse:
11550    '''
11551     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
11552     
11553     Deprecated: use Role access rules instead.
11554    '''
11555    __slots__ = [
11556        'meta',
11557        'rate_limit',
11558    ]
11559
11560    def __init__(
11561        self,
11562        meta=None,
11563        rate_limit=None,
11564    ):
11565        self.meta = meta if meta is not None else None
11566        '''
11567         Reserved for future use.
11568        '''
11569        self.rate_limit = rate_limit if rate_limit is not None else None
11570        '''
11571         Rate limit information.
11572        '''
11573
11574    def __repr__(self):
11575        return '<sdm.RoleGrantDeleteResponse ' + \
11576            'meta: ' + repr(self.meta) + ' ' +\
11577            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11578            '>'
11579
11580    def to_dict(self):
11581        return {
11582            'meta': self.meta,
11583            'rate_limit': self.rate_limit,
11584        }
11585
11586    @classmethod
11587    def from_dict(cls, d):
11588        return cls(
11589            meta=d.get('meta'),
11590            rate_limit=d.get('rate_limit'),
11591        )
11592
11593
11594class RoleGrantGetResponse:
11595    '''
11596     RoleGrantGetResponse returns a requested RoleGrant.
11597     
11598     Deprecated: use Role access rules instead.
11599    '''
11600    __slots__ = [
11601        'meta',
11602        'rate_limit',
11603        'role_grant',
11604    ]
11605
11606    def __init__(
11607        self,
11608        meta=None,
11609        rate_limit=None,
11610        role_grant=None,
11611    ):
11612        self.meta = meta if meta is not None else None
11613        '''
11614         Reserved for future use.
11615        '''
11616        self.rate_limit = rate_limit if rate_limit is not None else None
11617        '''
11618         Rate limit information.
11619        '''
11620        self.role_grant = role_grant if role_grant is not None else None
11621        '''
11622         The requested RoleGrant.
11623        '''
11624
11625    def __repr__(self):
11626        return '<sdm.RoleGrantGetResponse ' + \
11627            'meta: ' + repr(self.meta) + ' ' +\
11628            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11629            'role_grant: ' + repr(self.role_grant) + ' ' +\
11630            '>'
11631
11632    def to_dict(self):
11633        return {
11634            'meta': self.meta,
11635            'rate_limit': self.rate_limit,
11636            'role_grant': self.role_grant,
11637        }
11638
11639    @classmethod
11640    def from_dict(cls, d):
11641        return cls(
11642            meta=d.get('meta'),
11643            rate_limit=d.get('rate_limit'),
11644            role_grant=d.get('role_grant'),
11645        )
11646
11647
11648class RoleUpdateResponse:
11649    '''
11650     RoleUpdateResponse returns the fields of a Role after it has been updated by
11651     a RoleUpdateRequest.
11652    '''
11653    __slots__ = [
11654        'meta',
11655        'rate_limit',
11656        'role',
11657    ]
11658
11659    def __init__(
11660        self,
11661        meta=None,
11662        rate_limit=None,
11663        role=None,
11664    ):
11665        self.meta = meta if meta is not None else None
11666        '''
11667         Reserved for future use.
11668        '''
11669        self.rate_limit = rate_limit if rate_limit is not None else None
11670        '''
11671         Rate limit information.
11672        '''
11673        self.role = role if role is not None else None
11674        '''
11675         The updated Role.
11676        '''
11677
11678    def __repr__(self):
11679        return '<sdm.RoleUpdateResponse ' + \
11680            'meta: ' + repr(self.meta) + ' ' +\
11681            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11682            'role: ' + repr(self.role) + ' ' +\
11683            '>'
11684
11685    def to_dict(self):
11686        return {
11687            'meta': self.meta,
11688            'rate_limit': self.rate_limit,
11689            'role': self.role,
11690        }
11691
11692    @classmethod
11693    def from_dict(cls, d):
11694        return cls(
11695            meta=d.get('meta'),
11696            rate_limit=d.get('rate_limit'),
11697            role=d.get('role'),
11698        )
11699
11700
11701class SQLServer:
11702    '''
11703
11704    '''
11705    __slots__ = [
11706        'bind_interface',
11707        'database',
11708        'egress_filter',
11709        'healthy',
11710        'hostname',
11711        'id',
11712        'name',
11713        'override_database',
11714        'password',
11715        'port',
11716        'port_override',
11717        'schema',
11718        'secret_store_id',
11719        'tags',
11720        'username',
11721    ]
11722
11723    def __init__(
11724        self,
11725        bind_interface=None,
11726        database=None,
11727        egress_filter=None,
11728        healthy=None,
11729        hostname=None,
11730        id=None,
11731        name=None,
11732        override_database=None,
11733        password=None,
11734        port=None,
11735        port_override=None,
11736        schema=None,
11737        secret_store_id=None,
11738        tags=None,
11739        username=None,
11740    ):
11741        self.bind_interface = bind_interface if bind_interface is not None else ''
11742        '''
11743         Bind interface
11744        '''
11745        self.database = database if database is not None else ''
11746        '''
11747
11748        '''
11749        self.egress_filter = egress_filter if egress_filter is not None else ''
11750        '''
11751         A filter applied to the routing logic to pin datasource to nodes.
11752        '''
11753        self.healthy = healthy if healthy is not None else False
11754        '''
11755         True if the datasource is reachable and the credentials are valid.
11756        '''
11757        self.hostname = hostname if hostname is not None else ''
11758        '''
11759
11760        '''
11761        self.id = id if id is not None else ''
11762        '''
11763         Unique identifier of the Resource.
11764        '''
11765        self.name = name if name is not None else ''
11766        '''
11767         Unique human-readable name of the Resource.
11768        '''
11769        self.override_database = override_database if override_database is not None else False
11770        '''
11771
11772        '''
11773        self.password = password if password is not None else ''
11774        '''
11775
11776        '''
11777        self.port = port if port is not None else 0
11778        '''
11779
11780        '''
11781        self.port_override = port_override if port_override is not None else 0
11782        '''
11783
11784        '''
11785        self.schema = schema if schema is not None else ''
11786        '''
11787
11788        '''
11789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11790        '''
11791         ID of the secret store containing credentials for this resource, if any.
11792        '''
11793        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11794        '''
11795         Tags is a map of key, value pairs.
11796        '''
11797        self.username = username if username is not None else ''
11798        '''
11799
11800        '''
11801
11802    def __repr__(self):
11803        return '<sdm.SQLServer ' + \
11804            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11805            'database: ' + repr(self.database) + ' ' +\
11806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11807            'healthy: ' + repr(self.healthy) + ' ' +\
11808            'hostname: ' + repr(self.hostname) + ' ' +\
11809            'id: ' + repr(self.id) + ' ' +\
11810            'name: ' + repr(self.name) + ' ' +\
11811            'override_database: ' + repr(self.override_database) + ' ' +\
11812            'password: ' + repr(self.password) + ' ' +\
11813            'port: ' + repr(self.port) + ' ' +\
11814            'port_override: ' + repr(self.port_override) + ' ' +\
11815            'schema: ' + repr(self.schema) + ' ' +\
11816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11817            'tags: ' + repr(self.tags) + ' ' +\
11818            'username: ' + repr(self.username) + ' ' +\
11819            '>'
11820
11821    def to_dict(self):
11822        return {
11823            'bind_interface': self.bind_interface,
11824            'database': self.database,
11825            'egress_filter': self.egress_filter,
11826            'healthy': self.healthy,
11827            'hostname': self.hostname,
11828            'id': self.id,
11829            'name': self.name,
11830            'override_database': self.override_database,
11831            'password': self.password,
11832            'port': self.port,
11833            'port_override': self.port_override,
11834            'schema': self.schema,
11835            'secret_store_id': self.secret_store_id,
11836            'tags': self.tags,
11837            'username': self.username,
11838        }
11839
11840    @classmethod
11841    def from_dict(cls, d):
11842        return cls(
11843            bind_interface=d.get('bind_interface'),
11844            database=d.get('database'),
11845            egress_filter=d.get('egress_filter'),
11846            healthy=d.get('healthy'),
11847            hostname=d.get('hostname'),
11848            id=d.get('id'),
11849            name=d.get('name'),
11850            override_database=d.get('override_database'),
11851            password=d.get('password'),
11852            port=d.get('port'),
11853            port_override=d.get('port_override'),
11854            schema=d.get('schema'),
11855            secret_store_id=d.get('secret_store_id'),
11856            tags=d.get('tags'),
11857            username=d.get('username'),
11858        )
11859
11860
11861class SSH:
11862    '''
11863
11864    '''
11865    __slots__ = [
11866        'allow_deprecated_key_exchanges',
11867        'bind_interface',
11868        'egress_filter',
11869        'healthy',
11870        'hostname',
11871        'id',
11872        'key_type',
11873        'name',
11874        'port',
11875        'port_forwarding',
11876        'port_override',
11877        'public_key',
11878        'secret_store_id',
11879        'tags',
11880        'username',
11881    ]
11882
11883    def __init__(
11884        self,
11885        allow_deprecated_key_exchanges=None,
11886        bind_interface=None,
11887        egress_filter=None,
11888        healthy=None,
11889        hostname=None,
11890        id=None,
11891        key_type=None,
11892        name=None,
11893        port=None,
11894        port_forwarding=None,
11895        port_override=None,
11896        public_key=None,
11897        secret_store_id=None,
11898        tags=None,
11899        username=None,
11900    ):
11901        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11902        '''
11903
11904        '''
11905        self.bind_interface = bind_interface if bind_interface is not None else ''
11906        '''
11907         Bind interface
11908        '''
11909        self.egress_filter = egress_filter if egress_filter is not None else ''
11910        '''
11911         A filter applied to the routing logic to pin datasource to nodes.
11912        '''
11913        self.healthy = healthy if healthy is not None else False
11914        '''
11915         True if the datasource is reachable and the credentials are valid.
11916        '''
11917        self.hostname = hostname if hostname is not None else ''
11918        '''
11919
11920        '''
11921        self.id = id if id is not None else ''
11922        '''
11923         Unique identifier of the Resource.
11924        '''
11925        self.key_type = key_type if key_type is not None else ''
11926        '''
11927
11928        '''
11929        self.name = name if name is not None else ''
11930        '''
11931         Unique human-readable name of the Resource.
11932        '''
11933        self.port = port if port is not None else 0
11934        '''
11935
11936        '''
11937        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11938        '''
11939
11940        '''
11941        self.port_override = port_override if port_override is not None else 0
11942        '''
11943
11944        '''
11945        self.public_key = public_key if public_key is not None else ''
11946        '''
11947
11948        '''
11949        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11950        '''
11951         ID of the secret store containing credentials for this resource, if any.
11952        '''
11953        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11954        '''
11955         Tags is a map of key, value pairs.
11956        '''
11957        self.username = username if username is not None else ''
11958        '''
11959
11960        '''
11961
11962    def __repr__(self):
11963        return '<sdm.SSH ' + \
11964            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11965            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11966            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11967            'healthy: ' + repr(self.healthy) + ' ' +\
11968            'hostname: ' + repr(self.hostname) + ' ' +\
11969            'id: ' + repr(self.id) + ' ' +\
11970            'key_type: ' + repr(self.key_type) + ' ' +\
11971            'name: ' + repr(self.name) + ' ' +\
11972            'port: ' + repr(self.port) + ' ' +\
11973            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11974            'port_override: ' + repr(self.port_override) + ' ' +\
11975            'public_key: ' + repr(self.public_key) + ' ' +\
11976            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11977            'tags: ' + repr(self.tags) + ' ' +\
11978            'username: ' + repr(self.username) + ' ' +\
11979            '>'
11980
11981    def to_dict(self):
11982        return {
11983            'allow_deprecated_key_exchanges':
11984            self.allow_deprecated_key_exchanges,
11985            'bind_interface': self.bind_interface,
11986            'egress_filter': self.egress_filter,
11987            'healthy': self.healthy,
11988            'hostname': self.hostname,
11989            'id': self.id,
11990            'key_type': self.key_type,
11991            'name': self.name,
11992            'port': self.port,
11993            'port_forwarding': self.port_forwarding,
11994            'port_override': self.port_override,
11995            'public_key': self.public_key,
11996            'secret_store_id': self.secret_store_id,
11997            'tags': self.tags,
11998            'username': self.username,
11999        }
12000
12001    @classmethod
12002    def from_dict(cls, d):
12003        return cls(
12004            allow_deprecated_key_exchanges=d.get(
12005                'allow_deprecated_key_exchanges'),
12006            bind_interface=d.get('bind_interface'),
12007            egress_filter=d.get('egress_filter'),
12008            healthy=d.get('healthy'),
12009            hostname=d.get('hostname'),
12010            id=d.get('id'),
12011            key_type=d.get('key_type'),
12012            name=d.get('name'),
12013            port=d.get('port'),
12014            port_forwarding=d.get('port_forwarding'),
12015            port_override=d.get('port_override'),
12016            public_key=d.get('public_key'),
12017            secret_store_id=d.get('secret_store_id'),
12018            tags=d.get('tags'),
12019            username=d.get('username'),
12020        )
12021
12022
12023class SSHCert:
12024    '''
12025
12026    '''
12027    __slots__ = [
12028        'allow_deprecated_key_exchanges',
12029        'bind_interface',
12030        'egress_filter',
12031        'healthy',
12032        'hostname',
12033        'id',
12034        'key_type',
12035        'name',
12036        'port',
12037        'port_forwarding',
12038        'port_override',
12039        'remote_identity_group_id',
12040        'remote_identity_healthcheck_username',
12041        'secret_store_id',
12042        'tags',
12043        'username',
12044    ]
12045
12046    def __init__(
12047        self,
12048        allow_deprecated_key_exchanges=None,
12049        bind_interface=None,
12050        egress_filter=None,
12051        healthy=None,
12052        hostname=None,
12053        id=None,
12054        key_type=None,
12055        name=None,
12056        port=None,
12057        port_forwarding=None,
12058        port_override=None,
12059        remote_identity_group_id=None,
12060        remote_identity_healthcheck_username=None,
12061        secret_store_id=None,
12062        tags=None,
12063        username=None,
12064    ):
12065        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12066        '''
12067
12068        '''
12069        self.bind_interface = bind_interface if bind_interface is not None else ''
12070        '''
12071         Bind interface
12072        '''
12073        self.egress_filter = egress_filter if egress_filter is not None else ''
12074        '''
12075         A filter applied to the routing logic to pin datasource to nodes.
12076        '''
12077        self.healthy = healthy if healthy is not None else False
12078        '''
12079         True if the datasource is reachable and the credentials are valid.
12080        '''
12081        self.hostname = hostname if hostname is not None else ''
12082        '''
12083
12084        '''
12085        self.id = id if id is not None else ''
12086        '''
12087         Unique identifier of the Resource.
12088        '''
12089        self.key_type = key_type if key_type is not None else ''
12090        '''
12091
12092        '''
12093        self.name = name if name is not None else ''
12094        '''
12095         Unique human-readable name of the Resource.
12096        '''
12097        self.port = port if port is not None else 0
12098        '''
12099
12100        '''
12101        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12102        '''
12103
12104        '''
12105        self.port_override = port_override if port_override is not None else 0
12106        '''
12107
12108        '''
12109        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12110        '''
12111
12112        '''
12113        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12114        '''
12115
12116        '''
12117        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12118        '''
12119         ID of the secret store containing credentials for this resource, if any.
12120        '''
12121        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12122        '''
12123         Tags is a map of key, value pairs.
12124        '''
12125        self.username = username if username is not None else ''
12126        '''
12127
12128        '''
12129
12130    def __repr__(self):
12131        return '<sdm.SSHCert ' + \
12132            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12135            'healthy: ' + repr(self.healthy) + ' ' +\
12136            'hostname: ' + repr(self.hostname) + ' ' +\
12137            'id: ' + repr(self.id) + ' ' +\
12138            'key_type: ' + repr(self.key_type) + ' ' +\
12139            'name: ' + repr(self.name) + ' ' +\
12140            'port: ' + repr(self.port) + ' ' +\
12141            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12142            'port_override: ' + repr(self.port_override) + ' ' +\
12143            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
12144            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
12145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12146            'tags: ' + repr(self.tags) + ' ' +\
12147            'username: ' + repr(self.username) + ' ' +\
12148            '>'
12149
12150    def to_dict(self):
12151        return {
12152            'allow_deprecated_key_exchanges':
12153            self.allow_deprecated_key_exchanges,
12154            'bind_interface': self.bind_interface,
12155            'egress_filter': self.egress_filter,
12156            'healthy': self.healthy,
12157            'hostname': self.hostname,
12158            'id': self.id,
12159            'key_type': self.key_type,
12160            'name': self.name,
12161            'port': self.port,
12162            'port_forwarding': self.port_forwarding,
12163            'port_override': self.port_override,
12164            'remote_identity_group_id': self.remote_identity_group_id,
12165            'remote_identity_healthcheck_username':
12166            self.remote_identity_healthcheck_username,
12167            'secret_store_id': self.secret_store_id,
12168            'tags': self.tags,
12169            'username': self.username,
12170        }
12171
12172    @classmethod
12173    def from_dict(cls, d):
12174        return cls(
12175            allow_deprecated_key_exchanges=d.get(
12176                'allow_deprecated_key_exchanges'),
12177            bind_interface=d.get('bind_interface'),
12178            egress_filter=d.get('egress_filter'),
12179            healthy=d.get('healthy'),
12180            hostname=d.get('hostname'),
12181            id=d.get('id'),
12182            key_type=d.get('key_type'),
12183            name=d.get('name'),
12184            port=d.get('port'),
12185            port_forwarding=d.get('port_forwarding'),
12186            port_override=d.get('port_override'),
12187            remote_identity_group_id=d.get('remote_identity_group_id'),
12188            remote_identity_healthcheck_username=d.get(
12189                'remote_identity_healthcheck_username'),
12190            secret_store_id=d.get('secret_store_id'),
12191            tags=d.get('tags'),
12192            username=d.get('username'),
12193        )
12194
12195
12196class SSHCustomerKey:
12197    '''
12198
12199    '''
12200    __slots__ = [
12201        'allow_deprecated_key_exchanges',
12202        'bind_interface',
12203        'egress_filter',
12204        'healthy',
12205        'hostname',
12206        'id',
12207        'name',
12208        'port',
12209        'port_forwarding',
12210        'port_override',
12211        'private_key',
12212        'secret_store_id',
12213        'tags',
12214        'username',
12215    ]
12216
12217    def __init__(
12218        self,
12219        allow_deprecated_key_exchanges=None,
12220        bind_interface=None,
12221        egress_filter=None,
12222        healthy=None,
12223        hostname=None,
12224        id=None,
12225        name=None,
12226        port=None,
12227        port_forwarding=None,
12228        port_override=None,
12229        private_key=None,
12230        secret_store_id=None,
12231        tags=None,
12232        username=None,
12233    ):
12234        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12235        '''
12236
12237        '''
12238        self.bind_interface = bind_interface if bind_interface is not None else ''
12239        '''
12240         Bind interface
12241        '''
12242        self.egress_filter = egress_filter if egress_filter is not None else ''
12243        '''
12244         A filter applied to the routing logic to pin datasource to nodes.
12245        '''
12246        self.healthy = healthy if healthy is not None else False
12247        '''
12248         True if the datasource is reachable and the credentials are valid.
12249        '''
12250        self.hostname = hostname if hostname is not None else ''
12251        '''
12252
12253        '''
12254        self.id = id if id is not None else ''
12255        '''
12256         Unique identifier of the Resource.
12257        '''
12258        self.name = name if name is not None else ''
12259        '''
12260         Unique human-readable name of the Resource.
12261        '''
12262        self.port = port if port is not None else 0
12263        '''
12264
12265        '''
12266        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12267        '''
12268
12269        '''
12270        self.port_override = port_override if port_override is not None else 0
12271        '''
12272
12273        '''
12274        self.private_key = private_key if private_key is not None else ''
12275        '''
12276
12277        '''
12278        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12279        '''
12280         ID of the secret store containing credentials for this resource, if any.
12281        '''
12282        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12283        '''
12284         Tags is a map of key, value pairs.
12285        '''
12286        self.username = username if username is not None else ''
12287        '''
12288
12289        '''
12290
12291    def __repr__(self):
12292        return '<sdm.SSHCustomerKey ' + \
12293            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12294            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12295            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12296            'healthy: ' + repr(self.healthy) + ' ' +\
12297            'hostname: ' + repr(self.hostname) + ' ' +\
12298            'id: ' + repr(self.id) + ' ' +\
12299            'name: ' + repr(self.name) + ' ' +\
12300            'port: ' + repr(self.port) + ' ' +\
12301            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12302            'port_override: ' + repr(self.port_override) + ' ' +\
12303            'private_key: ' + repr(self.private_key) + ' ' +\
12304            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12305            'tags: ' + repr(self.tags) + ' ' +\
12306            'username: ' + repr(self.username) + ' ' +\
12307            '>'
12308
12309    def to_dict(self):
12310        return {
12311            'allow_deprecated_key_exchanges':
12312            self.allow_deprecated_key_exchanges,
12313            'bind_interface': self.bind_interface,
12314            'egress_filter': self.egress_filter,
12315            'healthy': self.healthy,
12316            'hostname': self.hostname,
12317            'id': self.id,
12318            'name': self.name,
12319            'port': self.port,
12320            'port_forwarding': self.port_forwarding,
12321            'port_override': self.port_override,
12322            'private_key': self.private_key,
12323            'secret_store_id': self.secret_store_id,
12324            'tags': self.tags,
12325            'username': self.username,
12326        }
12327
12328    @classmethod
12329    def from_dict(cls, d):
12330        return cls(
12331            allow_deprecated_key_exchanges=d.get(
12332                'allow_deprecated_key_exchanges'),
12333            bind_interface=d.get('bind_interface'),
12334            egress_filter=d.get('egress_filter'),
12335            healthy=d.get('healthy'),
12336            hostname=d.get('hostname'),
12337            id=d.get('id'),
12338            name=d.get('name'),
12339            port=d.get('port'),
12340            port_forwarding=d.get('port_forwarding'),
12341            port_override=d.get('port_override'),
12342            private_key=d.get('private_key'),
12343            secret_store_id=d.get('secret_store_id'),
12344            tags=d.get('tags'),
12345            username=d.get('username'),
12346        )
12347
12348
12349class SecretStoreCreateResponse:
12350    '''
12351     SecretStoreCreateResponse reports how the SecretStores were created in the system.
12352    '''
12353    __slots__ = [
12354        'meta',
12355        'rate_limit',
12356        'secret_store',
12357    ]
12358
12359    def __init__(
12360        self,
12361        meta=None,
12362        rate_limit=None,
12363        secret_store=None,
12364    ):
12365        self.meta = meta if meta is not None else None
12366        '''
12367         Reserved for future use.
12368        '''
12369        self.rate_limit = rate_limit if rate_limit is not None else None
12370        '''
12371         Rate limit information.
12372        '''
12373        self.secret_store = secret_store if secret_store is not None else None
12374        '''
12375         The created SecretStore.
12376        '''
12377
12378    def __repr__(self):
12379        return '<sdm.SecretStoreCreateResponse ' + \
12380            'meta: ' + repr(self.meta) + ' ' +\
12381            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12382            'secret_store: ' + repr(self.secret_store) + ' ' +\
12383            '>'
12384
12385    def to_dict(self):
12386        return {
12387            'meta': self.meta,
12388            'rate_limit': self.rate_limit,
12389            'secret_store': self.secret_store,
12390        }
12391
12392    @classmethod
12393    def from_dict(cls, d):
12394        return cls(
12395            meta=d.get('meta'),
12396            rate_limit=d.get('rate_limit'),
12397            secret_store=d.get('secret_store'),
12398        )
12399
12400
12401class SecretStoreDeleteResponse:
12402    '''
12403     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
12404    '''
12405    __slots__ = [
12406        'meta',
12407        'rate_limit',
12408    ]
12409
12410    def __init__(
12411        self,
12412        meta=None,
12413        rate_limit=None,
12414    ):
12415        self.meta = meta if meta is not None else None
12416        '''
12417         Reserved for future use.
12418        '''
12419        self.rate_limit = rate_limit if rate_limit is not None else None
12420        '''
12421         Rate limit information.
12422        '''
12423
12424    def __repr__(self):
12425        return '<sdm.SecretStoreDeleteResponse ' + \
12426            'meta: ' + repr(self.meta) + ' ' +\
12427            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12428            '>'
12429
12430    def to_dict(self):
12431        return {
12432            'meta': self.meta,
12433            'rate_limit': self.rate_limit,
12434        }
12435
12436    @classmethod
12437    def from_dict(cls, d):
12438        return cls(
12439            meta=d.get('meta'),
12440            rate_limit=d.get('rate_limit'),
12441        )
12442
12443
12444class SecretStoreGetResponse:
12445    '''
12446     SecretStoreGetResponse returns a requested SecretStore.
12447    '''
12448    __slots__ = [
12449        'meta',
12450        'rate_limit',
12451        'secret_store',
12452    ]
12453
12454    def __init__(
12455        self,
12456        meta=None,
12457        rate_limit=None,
12458        secret_store=None,
12459    ):
12460        self.meta = meta if meta is not None else None
12461        '''
12462         Reserved for future use.
12463        '''
12464        self.rate_limit = rate_limit if rate_limit is not None else None
12465        '''
12466         Rate limit information.
12467        '''
12468        self.secret_store = secret_store if secret_store is not None else None
12469        '''
12470         The requested SecretStore.
12471        '''
12472
12473    def __repr__(self):
12474        return '<sdm.SecretStoreGetResponse ' + \
12475            'meta: ' + repr(self.meta) + ' ' +\
12476            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12477            'secret_store: ' + repr(self.secret_store) + ' ' +\
12478            '>'
12479
12480    def to_dict(self):
12481        return {
12482            'meta': self.meta,
12483            'rate_limit': self.rate_limit,
12484            'secret_store': self.secret_store,
12485        }
12486
12487    @classmethod
12488    def from_dict(cls, d):
12489        return cls(
12490            meta=d.get('meta'),
12491            rate_limit=d.get('rate_limit'),
12492            secret_store=d.get('secret_store'),
12493        )
12494
12495
12496class SecretStoreUpdateResponse:
12497    '''
12498     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12499     a SecretStoreUpdateRequest.
12500    '''
12501    __slots__ = [
12502        'meta',
12503        'rate_limit',
12504        'secret_store',
12505    ]
12506
12507    def __init__(
12508        self,
12509        meta=None,
12510        rate_limit=None,
12511        secret_store=None,
12512    ):
12513        self.meta = meta if meta is not None else None
12514        '''
12515         Reserved for future use.
12516        '''
12517        self.rate_limit = rate_limit if rate_limit is not None else None
12518        '''
12519         Rate limit information.
12520        '''
12521        self.secret_store = secret_store if secret_store is not None else None
12522        '''
12523         The updated SecretStore.
12524        '''
12525
12526    def __repr__(self):
12527        return '<sdm.SecretStoreUpdateResponse ' + \
12528            'meta: ' + repr(self.meta) + ' ' +\
12529            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12530            'secret_store: ' + repr(self.secret_store) + ' ' +\
12531            '>'
12532
12533    def to_dict(self):
12534        return {
12535            'meta': self.meta,
12536            'rate_limit': self.rate_limit,
12537            'secret_store': self.secret_store,
12538        }
12539
12540    @classmethod
12541    def from_dict(cls, d):
12542        return cls(
12543            meta=d.get('meta'),
12544            rate_limit=d.get('rate_limit'),
12545            secret_store=d.get('secret_store'),
12546        )
12547
12548
12549class Service:
12550    '''
12551     A Service is a service account that can connect to resources they are granted
12552     directly, or granted via roles. Services are typically automated jobs.
12553    '''
12554    __slots__ = [
12555        'id',
12556        'name',
12557        'suspended',
12558        'tags',
12559    ]
12560
12561    def __init__(
12562        self,
12563        id=None,
12564        name=None,
12565        suspended=None,
12566        tags=None,
12567    ):
12568        self.id = id if id is not None else ''
12569        '''
12570         Unique identifier of the Service.
12571        '''
12572        self.name = name if name is not None else ''
12573        '''
12574         Unique human-readable name of the Service.
12575        '''
12576        self.suspended = suspended if suspended is not None else False
12577        '''
12578         The Service's suspended state.
12579        '''
12580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12581        '''
12582         Tags is a map of key, value pairs.
12583        '''
12584
12585    def __repr__(self):
12586        return '<sdm.Service ' + \
12587            'id: ' + repr(self.id) + ' ' +\
12588            'name: ' + repr(self.name) + ' ' +\
12589            'suspended: ' + repr(self.suspended) + ' ' +\
12590            'tags: ' + repr(self.tags) + ' ' +\
12591            '>'
12592
12593    def to_dict(self):
12594        return {
12595            'id': self.id,
12596            'name': self.name,
12597            'suspended': self.suspended,
12598            'tags': self.tags,
12599        }
12600
12601    @classmethod
12602    def from_dict(cls, d):
12603        return cls(
12604            id=d.get('id'),
12605            name=d.get('name'),
12606            suspended=d.get('suspended'),
12607            tags=d.get('tags'),
12608        )
12609
12610
12611class SingleStore:
12612    '''
12613
12614    '''
12615    __slots__ = [
12616        'bind_interface',
12617        'database',
12618        'egress_filter',
12619        'healthy',
12620        'hostname',
12621        'id',
12622        'name',
12623        'password',
12624        'port',
12625        'port_override',
12626        'secret_store_id',
12627        'tags',
12628        'username',
12629    ]
12630
12631    def __init__(
12632        self,
12633        bind_interface=None,
12634        database=None,
12635        egress_filter=None,
12636        healthy=None,
12637        hostname=None,
12638        id=None,
12639        name=None,
12640        password=None,
12641        port=None,
12642        port_override=None,
12643        secret_store_id=None,
12644        tags=None,
12645        username=None,
12646    ):
12647        self.bind_interface = bind_interface if bind_interface is not None else ''
12648        '''
12649         Bind interface
12650        '''
12651        self.database = database if database is not None else ''
12652        '''
12653
12654        '''
12655        self.egress_filter = egress_filter if egress_filter is not None else ''
12656        '''
12657         A filter applied to the routing logic to pin datasource to nodes.
12658        '''
12659        self.healthy = healthy if healthy is not None else False
12660        '''
12661         True if the datasource is reachable and the credentials are valid.
12662        '''
12663        self.hostname = hostname if hostname is not None else ''
12664        '''
12665
12666        '''
12667        self.id = id if id is not None else ''
12668        '''
12669         Unique identifier of the Resource.
12670        '''
12671        self.name = name if name is not None else ''
12672        '''
12673         Unique human-readable name of the Resource.
12674        '''
12675        self.password = password if password is not None else ''
12676        '''
12677
12678        '''
12679        self.port = port if port is not None else 0
12680        '''
12681
12682        '''
12683        self.port_override = port_override if port_override is not None else 0
12684        '''
12685
12686        '''
12687        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12688        '''
12689         ID of the secret store containing credentials for this resource, if any.
12690        '''
12691        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12692        '''
12693         Tags is a map of key, value pairs.
12694        '''
12695        self.username = username if username is not None else ''
12696        '''
12697
12698        '''
12699
12700    def __repr__(self):
12701        return '<sdm.SingleStore ' + \
12702            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12703            'database: ' + repr(self.database) + ' ' +\
12704            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12705            'healthy: ' + repr(self.healthy) + ' ' +\
12706            'hostname: ' + repr(self.hostname) + ' ' +\
12707            'id: ' + repr(self.id) + ' ' +\
12708            'name: ' + repr(self.name) + ' ' +\
12709            'password: ' + repr(self.password) + ' ' +\
12710            'port: ' + repr(self.port) + ' ' +\
12711            'port_override: ' + repr(self.port_override) + ' ' +\
12712            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12713            'tags: ' + repr(self.tags) + ' ' +\
12714            'username: ' + repr(self.username) + ' ' +\
12715            '>'
12716
12717    def to_dict(self):
12718        return {
12719            'bind_interface': self.bind_interface,
12720            'database': self.database,
12721            'egress_filter': self.egress_filter,
12722            'healthy': self.healthy,
12723            'hostname': self.hostname,
12724            'id': self.id,
12725            'name': self.name,
12726            'password': self.password,
12727            'port': self.port,
12728            'port_override': self.port_override,
12729            'secret_store_id': self.secret_store_id,
12730            'tags': self.tags,
12731            'username': self.username,
12732        }
12733
12734    @classmethod
12735    def from_dict(cls, d):
12736        return cls(
12737            bind_interface=d.get('bind_interface'),
12738            database=d.get('database'),
12739            egress_filter=d.get('egress_filter'),
12740            healthy=d.get('healthy'),
12741            hostname=d.get('hostname'),
12742            id=d.get('id'),
12743            name=d.get('name'),
12744            password=d.get('password'),
12745            port=d.get('port'),
12746            port_override=d.get('port_override'),
12747            secret_store_id=d.get('secret_store_id'),
12748            tags=d.get('tags'),
12749            username=d.get('username'),
12750        )
12751
12752
12753class Snowflake:
12754    '''
12755
12756    '''
12757    __slots__ = [
12758        'bind_interface',
12759        'database',
12760        'egress_filter',
12761        'healthy',
12762        'hostname',
12763        'id',
12764        'name',
12765        'password',
12766        'port_override',
12767        'schema',
12768        'secret_store_id',
12769        'tags',
12770        'username',
12771    ]
12772
12773    def __init__(
12774        self,
12775        bind_interface=None,
12776        database=None,
12777        egress_filter=None,
12778        healthy=None,
12779        hostname=None,
12780        id=None,
12781        name=None,
12782        password=None,
12783        port_override=None,
12784        schema=None,
12785        secret_store_id=None,
12786        tags=None,
12787        username=None,
12788    ):
12789        self.bind_interface = bind_interface if bind_interface is not None else ''
12790        '''
12791         Bind interface
12792        '''
12793        self.database = database if database is not None else ''
12794        '''
12795
12796        '''
12797        self.egress_filter = egress_filter if egress_filter is not None else ''
12798        '''
12799         A filter applied to the routing logic to pin datasource to nodes.
12800        '''
12801        self.healthy = healthy if healthy is not None else False
12802        '''
12803         True if the datasource is reachable and the credentials are valid.
12804        '''
12805        self.hostname = hostname if hostname is not None else ''
12806        '''
12807
12808        '''
12809        self.id = id if id is not None else ''
12810        '''
12811         Unique identifier of the Resource.
12812        '''
12813        self.name = name if name is not None else ''
12814        '''
12815         Unique human-readable name of the Resource.
12816        '''
12817        self.password = password if password is not None else ''
12818        '''
12819
12820        '''
12821        self.port_override = port_override if port_override is not None else 0
12822        '''
12823
12824        '''
12825        self.schema = schema if schema is not None else ''
12826        '''
12827
12828        '''
12829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12830        '''
12831         ID of the secret store containing credentials for this resource, if any.
12832        '''
12833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12834        '''
12835         Tags is a map of key, value pairs.
12836        '''
12837        self.username = username if username is not None else ''
12838        '''
12839
12840        '''
12841
12842    def __repr__(self):
12843        return '<sdm.Snowflake ' + \
12844            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12845            'database: ' + repr(self.database) + ' ' +\
12846            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12847            'healthy: ' + repr(self.healthy) + ' ' +\
12848            'hostname: ' + repr(self.hostname) + ' ' +\
12849            'id: ' + repr(self.id) + ' ' +\
12850            'name: ' + repr(self.name) + ' ' +\
12851            'password: ' + repr(self.password) + ' ' +\
12852            'port_override: ' + repr(self.port_override) + ' ' +\
12853            'schema: ' + repr(self.schema) + ' ' +\
12854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12855            'tags: ' + repr(self.tags) + ' ' +\
12856            'username: ' + repr(self.username) + ' ' +\
12857            '>'
12858
12859    def to_dict(self):
12860        return {
12861            'bind_interface': self.bind_interface,
12862            'database': self.database,
12863            'egress_filter': self.egress_filter,
12864            'healthy': self.healthy,
12865            'hostname': self.hostname,
12866            'id': self.id,
12867            'name': self.name,
12868            'password': self.password,
12869            'port_override': self.port_override,
12870            'schema': self.schema,
12871            'secret_store_id': self.secret_store_id,
12872            'tags': self.tags,
12873            'username': self.username,
12874        }
12875
12876    @classmethod
12877    def from_dict(cls, d):
12878        return cls(
12879            bind_interface=d.get('bind_interface'),
12880            database=d.get('database'),
12881            egress_filter=d.get('egress_filter'),
12882            healthy=d.get('healthy'),
12883            hostname=d.get('hostname'),
12884            id=d.get('id'),
12885            name=d.get('name'),
12886            password=d.get('password'),
12887            port_override=d.get('port_override'),
12888            schema=d.get('schema'),
12889            secret_store_id=d.get('secret_store_id'),
12890            tags=d.get('tags'),
12891            username=d.get('username'),
12892        )
12893
12894
12895class Sybase:
12896    '''
12897
12898    '''
12899    __slots__ = [
12900        'bind_interface',
12901        'egress_filter',
12902        'healthy',
12903        'hostname',
12904        'id',
12905        'name',
12906        'password',
12907        'port',
12908        'port_override',
12909        'secret_store_id',
12910        'tags',
12911        'username',
12912    ]
12913
12914    def __init__(
12915        self,
12916        bind_interface=None,
12917        egress_filter=None,
12918        healthy=None,
12919        hostname=None,
12920        id=None,
12921        name=None,
12922        password=None,
12923        port=None,
12924        port_override=None,
12925        secret_store_id=None,
12926        tags=None,
12927        username=None,
12928    ):
12929        self.bind_interface = bind_interface if bind_interface is not None else ''
12930        '''
12931         Bind interface
12932        '''
12933        self.egress_filter = egress_filter if egress_filter is not None else ''
12934        '''
12935         A filter applied to the routing logic to pin datasource to nodes.
12936        '''
12937        self.healthy = healthy if healthy is not None else False
12938        '''
12939         True if the datasource is reachable and the credentials are valid.
12940        '''
12941        self.hostname = hostname if hostname is not None else ''
12942        '''
12943
12944        '''
12945        self.id = id if id is not None else ''
12946        '''
12947         Unique identifier of the Resource.
12948        '''
12949        self.name = name if name is not None else ''
12950        '''
12951         Unique human-readable name of the Resource.
12952        '''
12953        self.password = password if password is not None else ''
12954        '''
12955
12956        '''
12957        self.port = port if port is not None else 0
12958        '''
12959
12960        '''
12961        self.port_override = port_override if port_override is not None else 0
12962        '''
12963
12964        '''
12965        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12966        '''
12967         ID of the secret store containing credentials for this resource, if any.
12968        '''
12969        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12970        '''
12971         Tags is a map of key, value pairs.
12972        '''
12973        self.username = username if username is not None else ''
12974        '''
12975
12976        '''
12977
12978    def __repr__(self):
12979        return '<sdm.Sybase ' + \
12980            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12981            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12982            'healthy: ' + repr(self.healthy) + ' ' +\
12983            'hostname: ' + repr(self.hostname) + ' ' +\
12984            'id: ' + repr(self.id) + ' ' +\
12985            'name: ' + repr(self.name) + ' ' +\
12986            'password: ' + repr(self.password) + ' ' +\
12987            'port: ' + repr(self.port) + ' ' +\
12988            'port_override: ' + repr(self.port_override) + ' ' +\
12989            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12990            'tags: ' + repr(self.tags) + ' ' +\
12991            'username: ' + repr(self.username) + ' ' +\
12992            '>'
12993
12994    def to_dict(self):
12995        return {
12996            'bind_interface': self.bind_interface,
12997            'egress_filter': self.egress_filter,
12998            'healthy': self.healthy,
12999            'hostname': self.hostname,
13000            'id': self.id,
13001            'name': self.name,
13002            'password': self.password,
13003            'port': self.port,
13004            'port_override': self.port_override,
13005            'secret_store_id': self.secret_store_id,
13006            'tags': self.tags,
13007            'username': self.username,
13008        }
13009
13010    @classmethod
13011    def from_dict(cls, d):
13012        return cls(
13013            bind_interface=d.get('bind_interface'),
13014            egress_filter=d.get('egress_filter'),
13015            healthy=d.get('healthy'),
13016            hostname=d.get('hostname'),
13017            id=d.get('id'),
13018            name=d.get('name'),
13019            password=d.get('password'),
13020            port=d.get('port'),
13021            port_override=d.get('port_override'),
13022            secret_store_id=d.get('secret_store_id'),
13023            tags=d.get('tags'),
13024            username=d.get('username'),
13025        )
13026
13027
13028class SybaseIQ:
13029    '''
13030
13031    '''
13032    __slots__ = [
13033        'bind_interface',
13034        'egress_filter',
13035        'healthy',
13036        'hostname',
13037        'id',
13038        'name',
13039        'password',
13040        'port',
13041        'port_override',
13042        'secret_store_id',
13043        'tags',
13044        'username',
13045    ]
13046
13047    def __init__(
13048        self,
13049        bind_interface=None,
13050        egress_filter=None,
13051        healthy=None,
13052        hostname=None,
13053        id=None,
13054        name=None,
13055        password=None,
13056        port=None,
13057        port_override=None,
13058        secret_store_id=None,
13059        tags=None,
13060        username=None,
13061    ):
13062        self.bind_interface = bind_interface if bind_interface is not None else ''
13063        '''
13064         Bind interface
13065        '''
13066        self.egress_filter = egress_filter if egress_filter is not None else ''
13067        '''
13068         A filter applied to the routing logic to pin datasource to nodes.
13069        '''
13070        self.healthy = healthy if healthy is not None else False
13071        '''
13072         True if the datasource is reachable and the credentials are valid.
13073        '''
13074        self.hostname = hostname if hostname is not None else ''
13075        '''
13076
13077        '''
13078        self.id = id if id is not None else ''
13079        '''
13080         Unique identifier of the Resource.
13081        '''
13082        self.name = name if name is not None else ''
13083        '''
13084         Unique human-readable name of the Resource.
13085        '''
13086        self.password = password if password is not None else ''
13087        '''
13088
13089        '''
13090        self.port = port if port is not None else 0
13091        '''
13092
13093        '''
13094        self.port_override = port_override if port_override is not None else 0
13095        '''
13096
13097        '''
13098        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13099        '''
13100         ID of the secret store containing credentials for this resource, if any.
13101        '''
13102        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13103        '''
13104         Tags is a map of key, value pairs.
13105        '''
13106        self.username = username if username is not None else ''
13107        '''
13108
13109        '''
13110
13111    def __repr__(self):
13112        return '<sdm.SybaseIQ ' + \
13113            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13114            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13115            'healthy: ' + repr(self.healthy) + ' ' +\
13116            'hostname: ' + repr(self.hostname) + ' ' +\
13117            'id: ' + repr(self.id) + ' ' +\
13118            'name: ' + repr(self.name) + ' ' +\
13119            'password: ' + repr(self.password) + ' ' +\
13120            'port: ' + repr(self.port) + ' ' +\
13121            'port_override: ' + repr(self.port_override) + ' ' +\
13122            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13123            'tags: ' + repr(self.tags) + ' ' +\
13124            'username: ' + repr(self.username) + ' ' +\
13125            '>'
13126
13127    def to_dict(self):
13128        return {
13129            'bind_interface': self.bind_interface,
13130            'egress_filter': self.egress_filter,
13131            'healthy': self.healthy,
13132            'hostname': self.hostname,
13133            'id': self.id,
13134            'name': self.name,
13135            'password': self.password,
13136            'port': self.port,
13137            'port_override': self.port_override,
13138            'secret_store_id': self.secret_store_id,
13139            'tags': self.tags,
13140            'username': self.username,
13141        }
13142
13143    @classmethod
13144    def from_dict(cls, d):
13145        return cls(
13146            bind_interface=d.get('bind_interface'),
13147            egress_filter=d.get('egress_filter'),
13148            healthy=d.get('healthy'),
13149            hostname=d.get('hostname'),
13150            id=d.get('id'),
13151            name=d.get('name'),
13152            password=d.get('password'),
13153            port=d.get('port'),
13154            port_override=d.get('port_override'),
13155            secret_store_id=d.get('secret_store_id'),
13156            tags=d.get('tags'),
13157            username=d.get('username'),
13158        )
13159
13160
13161class Tag:
13162    '''
13163
13164    '''
13165    __slots__ = [
13166        'name',
13167        'value',
13168    ]
13169
13170    def __init__(
13171        self,
13172        name=None,
13173        value=None,
13174    ):
13175        self.name = name if name is not None else ''
13176        '''
13177
13178        '''
13179        self.value = value if value is not None else ''
13180        '''
13181
13182        '''
13183
13184    def __repr__(self):
13185        return '<sdm.Tag ' + \
13186            'name: ' + repr(self.name) + ' ' +\
13187            'value: ' + repr(self.value) + ' ' +\
13188            '>'
13189
13190    def to_dict(self):
13191        return {
13192            'name': self.name,
13193            'value': self.value,
13194        }
13195
13196    @classmethod
13197    def from_dict(cls, d):
13198        return cls(
13199            name=d.get('name'),
13200            value=d.get('value'),
13201        )
13202
13203
13204class Teradata:
13205    '''
13206
13207    '''
13208    __slots__ = [
13209        'bind_interface',
13210        'egress_filter',
13211        'healthy',
13212        'hostname',
13213        'id',
13214        'name',
13215        'password',
13216        'port',
13217        'port_override',
13218        'secret_store_id',
13219        'tags',
13220        'username',
13221    ]
13222
13223    def __init__(
13224        self,
13225        bind_interface=None,
13226        egress_filter=None,
13227        healthy=None,
13228        hostname=None,
13229        id=None,
13230        name=None,
13231        password=None,
13232        port=None,
13233        port_override=None,
13234        secret_store_id=None,
13235        tags=None,
13236        username=None,
13237    ):
13238        self.bind_interface = bind_interface if bind_interface is not None else ''
13239        '''
13240         Bind interface
13241        '''
13242        self.egress_filter = egress_filter if egress_filter is not None else ''
13243        '''
13244         A filter applied to the routing logic to pin datasource to nodes.
13245        '''
13246        self.healthy = healthy if healthy is not None else False
13247        '''
13248         True if the datasource is reachable and the credentials are valid.
13249        '''
13250        self.hostname = hostname if hostname is not None else ''
13251        '''
13252
13253        '''
13254        self.id = id if id is not None else ''
13255        '''
13256         Unique identifier of the Resource.
13257        '''
13258        self.name = name if name is not None else ''
13259        '''
13260         Unique human-readable name of the Resource.
13261        '''
13262        self.password = password if password is not None else ''
13263        '''
13264
13265        '''
13266        self.port = port if port is not None else 0
13267        '''
13268
13269        '''
13270        self.port_override = port_override if port_override is not None else 0
13271        '''
13272
13273        '''
13274        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13275        '''
13276         ID of the secret store containing credentials for this resource, if any.
13277        '''
13278        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13279        '''
13280         Tags is a map of key, value pairs.
13281        '''
13282        self.username = username if username is not None else ''
13283        '''
13284
13285        '''
13286
13287    def __repr__(self):
13288        return '<sdm.Teradata ' + \
13289            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13290            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13291            'healthy: ' + repr(self.healthy) + ' ' +\
13292            'hostname: ' + repr(self.hostname) + ' ' +\
13293            'id: ' + repr(self.id) + ' ' +\
13294            'name: ' + repr(self.name) + ' ' +\
13295            'password: ' + repr(self.password) + ' ' +\
13296            'port: ' + repr(self.port) + ' ' +\
13297            'port_override: ' + repr(self.port_override) + ' ' +\
13298            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13299            'tags: ' + repr(self.tags) + ' ' +\
13300            'username: ' + repr(self.username) + ' ' +\
13301            '>'
13302
13303    def to_dict(self):
13304        return {
13305            'bind_interface': self.bind_interface,
13306            'egress_filter': self.egress_filter,
13307            'healthy': self.healthy,
13308            'hostname': self.hostname,
13309            'id': self.id,
13310            'name': self.name,
13311            'password': self.password,
13312            'port': self.port,
13313            'port_override': self.port_override,
13314            'secret_store_id': self.secret_store_id,
13315            'tags': self.tags,
13316            'username': self.username,
13317        }
13318
13319    @classmethod
13320    def from_dict(cls, d):
13321        return cls(
13322            bind_interface=d.get('bind_interface'),
13323            egress_filter=d.get('egress_filter'),
13324            healthy=d.get('healthy'),
13325            hostname=d.get('hostname'),
13326            id=d.get('id'),
13327            name=d.get('name'),
13328            password=d.get('password'),
13329            port=d.get('port'),
13330            port_override=d.get('port_override'),
13331            secret_store_id=d.get('secret_store_id'),
13332            tags=d.get('tags'),
13333            username=d.get('username'),
13334        )
13335
13336
13337class UpdateResponseMetadata:
13338    '''
13339     UpdateResponseMetadata is reserved for future use.
13340    '''
13341    __slots__ = []
13342
13343    def __init__(self, ):
13344        pass
13345
13346    def __repr__(self):
13347        return '<sdm.UpdateResponseMetadata ' + \
13348            '>'
13349
13350    def to_dict(self):
13351        return {}
13352
13353    @classmethod
13354    def from_dict(cls, d):
13355        return cls()
13356
13357
13358class User:
13359    '''
13360     A User can connect to resources they are granted directly, or granted
13361     via roles.
13362    '''
13363    __slots__ = [
13364        'email',
13365        'first_name',
13366        'id',
13367        'last_name',
13368        'suspended',
13369        'tags',
13370    ]
13371
13372    def __init__(
13373        self,
13374        email=None,
13375        first_name=None,
13376        id=None,
13377        last_name=None,
13378        suspended=None,
13379        tags=None,
13380    ):
13381        self.email = email if email is not None else ''
13382        '''
13383         The User's email address. Must be unique.
13384        '''
13385        self.first_name = first_name if first_name is not None else ''
13386        '''
13387         The User's first name.
13388        '''
13389        self.id = id if id is not None else ''
13390        '''
13391         Unique identifier of the User.
13392        '''
13393        self.last_name = last_name if last_name is not None else ''
13394        '''
13395         The User's last name.
13396        '''
13397        self.suspended = suspended if suspended is not None else False
13398        '''
13399         The User's suspended state.
13400        '''
13401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13402        '''
13403         Tags is a map of key, value pairs.
13404        '''
13405
13406    def __repr__(self):
13407        return '<sdm.User ' + \
13408            'email: ' + repr(self.email) + ' ' +\
13409            'first_name: ' + repr(self.first_name) + ' ' +\
13410            'id: ' + repr(self.id) + ' ' +\
13411            'last_name: ' + repr(self.last_name) + ' ' +\
13412            'suspended: ' + repr(self.suspended) + ' ' +\
13413            'tags: ' + repr(self.tags) + ' ' +\
13414            '>'
13415
13416    def to_dict(self):
13417        return {
13418            'email': self.email,
13419            'first_name': self.first_name,
13420            'id': self.id,
13421            'last_name': self.last_name,
13422            'suspended': self.suspended,
13423            'tags': self.tags,
13424        }
13425
13426    @classmethod
13427    def from_dict(cls, d):
13428        return cls(
13429            email=d.get('email'),
13430            first_name=d.get('first_name'),
13431            id=d.get('id'),
13432            last_name=d.get('last_name'),
13433            suspended=d.get('suspended'),
13434            tags=d.get('tags'),
13435        )
13436
13437
13438class VaultAppRoleStore:
13439    '''
13440
13441    '''
13442    __slots__ = [
13443        'id',
13444        'name',
13445        'namespace',
13446        'server_address',
13447        'tags',
13448    ]
13449
13450    def __init__(
13451        self,
13452        id=None,
13453        name=None,
13454        namespace=None,
13455        server_address=None,
13456        tags=None,
13457    ):
13458        self.id = id if id is not None else ''
13459        '''
13460         Unique identifier of the SecretStore.
13461        '''
13462        self.name = name if name is not None else ''
13463        '''
13464         Unique human-readable name of the SecretStore.
13465        '''
13466        self.namespace = namespace if namespace is not None else ''
13467        '''
13468
13469        '''
13470        self.server_address = server_address if server_address is not None else ''
13471        '''
13472
13473        '''
13474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13475        '''
13476         Tags is a map of key, value pairs.
13477        '''
13478
13479    def __repr__(self):
13480        return '<sdm.VaultAppRoleStore ' + \
13481            'id: ' + repr(self.id) + ' ' +\
13482            'name: ' + repr(self.name) + ' ' +\
13483            'namespace: ' + repr(self.namespace) + ' ' +\
13484            'server_address: ' + repr(self.server_address) + ' ' +\
13485            'tags: ' + repr(self.tags) + ' ' +\
13486            '>'
13487
13488    def to_dict(self):
13489        return {
13490            'id': self.id,
13491            'name': self.name,
13492            'namespace': self.namespace,
13493            'server_address': self.server_address,
13494            'tags': self.tags,
13495        }
13496
13497    @classmethod
13498    def from_dict(cls, d):
13499        return cls(
13500            id=d.get('id'),
13501            name=d.get('name'),
13502            namespace=d.get('namespace'),
13503            server_address=d.get('server_address'),
13504            tags=d.get('tags'),
13505        )
13506
13507
13508class VaultTLSStore:
13509    '''
13510
13511    '''
13512    __slots__ = [
13513        'ca_cert_path',
13514        'client_cert_path',
13515        'client_key_path',
13516        'id',
13517        'name',
13518        'namespace',
13519        'server_address',
13520        'tags',
13521    ]
13522
13523    def __init__(
13524        self,
13525        ca_cert_path=None,
13526        client_cert_path=None,
13527        client_key_path=None,
13528        id=None,
13529        name=None,
13530        namespace=None,
13531        server_address=None,
13532        tags=None,
13533    ):
13534        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13535        '''
13536
13537        '''
13538        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13539        '''
13540
13541        '''
13542        self.client_key_path = client_key_path if client_key_path is not None else ''
13543        '''
13544
13545        '''
13546        self.id = id if id is not None else ''
13547        '''
13548         Unique identifier of the SecretStore.
13549        '''
13550        self.name = name if name is not None else ''
13551        '''
13552         Unique human-readable name of the SecretStore.
13553        '''
13554        self.namespace = namespace if namespace is not None else ''
13555        '''
13556
13557        '''
13558        self.server_address = server_address if server_address is not None else ''
13559        '''
13560
13561        '''
13562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13563        '''
13564         Tags is a map of key, value pairs.
13565        '''
13566
13567    def __repr__(self):
13568        return '<sdm.VaultTLSStore ' + \
13569            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13570            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13571            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13572            'id: ' + repr(self.id) + ' ' +\
13573            'name: ' + repr(self.name) + ' ' +\
13574            'namespace: ' + repr(self.namespace) + ' ' +\
13575            'server_address: ' + repr(self.server_address) + ' ' +\
13576            'tags: ' + repr(self.tags) + ' ' +\
13577            '>'
13578
13579    def to_dict(self):
13580        return {
13581            'ca_cert_path': self.ca_cert_path,
13582            'client_cert_path': self.client_cert_path,
13583            'client_key_path': self.client_key_path,
13584            'id': self.id,
13585            'name': self.name,
13586            'namespace': self.namespace,
13587            'server_address': self.server_address,
13588            'tags': self.tags,
13589        }
13590
13591    @classmethod
13592    def from_dict(cls, d):
13593        return cls(
13594            ca_cert_path=d.get('ca_cert_path'),
13595            client_cert_path=d.get('client_cert_path'),
13596            client_key_path=d.get('client_key_path'),
13597            id=d.get('id'),
13598            name=d.get('name'),
13599            namespace=d.get('namespace'),
13600            server_address=d.get('server_address'),
13601            tags=d.get('tags'),
13602        )
13603
13604
13605class VaultTokenStore:
13606    '''
13607
13608    '''
13609    __slots__ = [
13610        'id',
13611        'name',
13612        'namespace',
13613        'server_address',
13614        'tags',
13615    ]
13616
13617    def __init__(
13618        self,
13619        id=None,
13620        name=None,
13621        namespace=None,
13622        server_address=None,
13623        tags=None,
13624    ):
13625        self.id = id if id is not None else ''
13626        '''
13627         Unique identifier of the SecretStore.
13628        '''
13629        self.name = name if name is not None else ''
13630        '''
13631         Unique human-readable name of the SecretStore.
13632        '''
13633        self.namespace = namespace if namespace is not None else ''
13634        '''
13635
13636        '''
13637        self.server_address = server_address if server_address is not None else ''
13638        '''
13639
13640        '''
13641        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13642        '''
13643         Tags is a map of key, value pairs.
13644        '''
13645
13646    def __repr__(self):
13647        return '<sdm.VaultTokenStore ' + \
13648            'id: ' + repr(self.id) + ' ' +\
13649            'name: ' + repr(self.name) + ' ' +\
13650            'namespace: ' + repr(self.namespace) + ' ' +\
13651            'server_address: ' + repr(self.server_address) + ' ' +\
13652            'tags: ' + repr(self.tags) + ' ' +\
13653            '>'
13654
13655    def to_dict(self):
13656        return {
13657            'id': self.id,
13658            'name': self.name,
13659            'namespace': self.namespace,
13660            'server_address': self.server_address,
13661            'tags': self.tags,
13662        }
13663
13664    @classmethod
13665    def from_dict(cls, d):
13666        return cls(
13667            id=d.get('id'),
13668            name=d.get('name'),
13669            namespace=d.get('namespace'),
13670            server_address=d.get('server_address'),
13671            tags=d.get('tags'),
13672        )
13673
13674
13675def _porcelain_zero_value_tags():
13676    return {}
13677
13678
13679def _porcelain_zero_value_access_rules():
13680    return []